Changeset 33415 for branches/meh_branches/ppstack_test/psModules

Timestamp:

Mar 5, 2012, 5:19:48 PM (14 years ago)

Author:

mhuber

Message:

merging latest r33407 trunk changes to meh_branches/ppstack_test

Location:

branches/meh_branches/ppstack_test

Files:

• . (modified) (1 prop)
• psModules (modified) (1 prop)
• psModules/src/astrom/pmAstrometryWCS.c (modified) (1 diff)
• psModules/src/camera/pmReadoutFake.c (modified) (3 diffs)
• psModules/src/concepts/pmConceptsStandard.c (modified) (1 diff)
• psModules/src/detrend/pmBias.c (modified) (1 diff)
• psModules/src/detrend/pmDark.c (modified) (1 diff)
• psModules/src/detrend/pmFlatField.c (modified) (1 diff)
• psModules/src/detrend/pmPattern.c (modified) (7 diffs)
• psModules/src/detrend/pmPattern.h (modified) (1 diff)
• psModules/src/detrend/pmShutterCorrection.c (modified) (1 diff)
• psModules/src/imcombine/pmPSFEnvelope.c (modified) (2 diffs)
• psModules/src/imcombine/pmStackReject.c (modified) (1 diff)
• psModules/src/imcombine/pmSubtraction.c (modified) (6 diffs)
• psModules/src/imcombine/pmSubtractionEquation.c (modified) (8 diffs)
• psModules/src/imcombine/pmSubtractionEquation.v0.c (modified) (1 diff)
• psModules/src/imcombine/pmSubtractionMatch.c (modified) (8 diffs)
• psModules/src/imcombine/pmSubtractionStamps.c (modified) (10 diffs)
• psModules/src/imcombine/pmSubtractionStamps.h (modified) (1 diff)
• psModules/src/objects (modified) (1 prop)
• psModules/src/objects/Makefile.am (modified) (2 diffs)
• psModules/src/objects/mksource.pl (modified) (2 diffs)
• psModules/src/objects/models/pmModel_DEV.c (modified) (7 diffs)
• psModules/src/objects/models/pmModel_EXP.c (modified) (6 diffs)
• psModules/src/objects/models/pmModel_PGAUSS.c (modified) (2 diffs)
• psModules/src/objects/models/pmModel_PS1_V1.c (modified) (3 diffs)
• psModules/src/objects/models/pmModel_QGAUSS.c (modified) (2 diffs)
• psModules/src/objects/models/pmModel_RGAUSS.c (modified) (2 diffs)
• psModules/src/objects/models/pmModel_SERSIC.CP.h (copied) (copied from trunk/psModules/src/objects/models/pmModel_SERSIC.CP.h )
• psModules/src/objects/models/pmModel_SERSIC.c (modified) (7 diffs)
• psModules/src/objects/pmFootprintCullPeaks.c (modified) (2 diffs)
• psModules/src/objects/pmModelUtils.c (modified) (1 diff)
• psModules/src/objects/pmMoments.c (modified) (2 diffs)
• psModules/src/objects/pmMoments.h (modified) (1 diff)
• psModules/src/objects/pmPCM_MinimizeChisq.c (modified) (6 diffs)
• psModules/src/objects/pmPCMdata.c (modified) (5 diffs)
• psModules/src/objects/pmPCMdata.h (modified) (2 diffs)
• psModules/src/objects/pmPSF.c (modified) (7 diffs)
• psModules/src/objects/pmPSF.h (modified) (1 diff)
• psModules/src/objects/pmPeaks.c (modified) (3 diffs)
• psModules/src/objects/pmPeaks.h (modified) (1 diff)
• psModules/src/objects/pmSource.c (modified) (7 diffs)
• psModules/src/objects/pmSource.h (modified) (3 diffs)
• psModules/src/objects/pmSourceExtendedPars.c (modified) (1 diff)
• psModules/src/objects/pmSourceExtendedPars.h (modified) (2 diffs)
• psModules/src/objects/pmSourceFitModel.c (modified) (2 diffs)
• psModules/src/objects/pmSourceFitPCM.c (modified) (6 diffs)
• psModules/src/objects/pmSourceIO.c (modified) (6 diffs)
• psModules/src/objects/pmSourceIO.h (modified) (2 diffs)
• psModules/src/objects/pmSourceIO_CMF.c.in (modified) (16 diffs)
• psModules/src/objects/pmSourceIO_CMF_PS1_DV1.c (modified) (2 diffs)
• psModules/src/objects/pmSourceIO_CMF_PS1_DV2.c (modified) (2 diffs)
• psModules/src/objects/pmSourceIO_CMF_PS1_SV1.c (modified) (5 diffs)
• psModules/src/objects/pmSourceIO_CMF_PS1_V1.c (deleted)
• psModules/src/objects/pmSourceIO_CMF_PS1_V2.c (deleted)
• psModules/src/objects/pmSourceIO_CMF_PS1_V3.c (deleted)
• psModules/src/objects/pmSourceIO_CMP.c (modified) (2 diffs)
• psModules/src/objects/pmSourceIO_OBJ.c (modified) (1 diff)
• psModules/src/objects/pmSourceIO_PS1_CAL_0.c (modified) (3 diffs)
• psModules/src/objects/pmSourceIO_PS1_DEV_0.c (modified) (2 diffs)
• psModules/src/objects/pmSourceIO_PS1_DEV_1.c (modified) (3 diffs)
• psModules/src/objects/pmSourceIO_SMPDATA.c (modified) (2 diffs)
• psModules/src/objects/pmSourceIO_SX.c (modified) (1 diff)
• psModules/src/objects/pmSourceMasks.h (modified) (1 diff)
• psModules/src/objects/pmSourceMoments.c (modified) (10 diffs)
• psModules/src/objects/pmSourceOutputs.c (modified) (2 diffs)
• psModules/src/objects/pmSourceOutputs.h (modified) (1 diff)
• psModules/src/objects/pmSourcePhotometry.c (modified) (4 diffs)
• psModules/src/objects/pmSourcePlotPSFModel.c (modified) (1 diff)

branches/meh_branches/ppstack_test/psModules/src/astrom/pmAstrometryWCS.c

@@ -487 +487 @@
 
     if (fpa->toSky == NULL) {
+        psFree(fpa->toTPA);
+        psFree(fpa->fromTPA);
         fpa->toTPA = psPlaneTransformIdentity (1);
         fpa->fromTPA = psPlaneTransformIdentity (1);

branches/meh_branches/ppstack_test/psModules/src/camera/pmReadoutFake.c

@@ -51 +51 @@
 
     psF32 *params = model->params->data.F32; // Model parameters
-    psEllipseAxes axes = pmPSF_ModelToAxes(params, MAX_AXIS_RATIO); // Ellipse axes
+    psEllipseAxes axes = pmPSF_ModelToAxes(params, MAX_AXIS_RATIO, model->type); // Ellipse axes
     // Curiously, the minor axis can be larger than the major axis, so need to check.
     if (axes.major >= axes.minor) {
@@ -58 +58 @@
         axes.major = axes.minor;
     }
-    return pmPSF_AxesToModel(params, axes);
+    return pmPSF_AxesToModel(params, axes, model->type);
 }
 
@@ -314 +314 @@
                 }
             }
-            if (!psThreadPoolWait(true)) {
+            if (!psThreadPoolWait(true, true)) {
                 psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
                 psFree(groups);

branches/meh_branches/ppstack_test/psModules/src/concepts/pmConceptsStandard.c

@@ -751 +751 @@
   bool has_video_cell = false;
 
-  if (concept->type != PS_DATA_STRING) {
-    psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Type for %s (%x) is not string\n",
-            concept->name, concept->type);
-    return NULL;
-  }
-
-  char *Vptr = strchr(concept->data.V,'V');
-  if (Vptr) {
-    has_video_cell = true;
+  if (concept->type == PS_DATA_BOOL) {
+    has_video_cell = concept->data.B;
+  } else { 
+    if (concept->type != PS_DATA_STRING) {
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Type for %s (%x) is not string\n",
+                concept->name, concept->type);
+        return NULL;
+      }
+
+      char *Vptr = strchr(concept->data.V,'V');
+      if (Vptr) {
+        has_video_cell = true;
+      }
   }
 

branches/meh_branches/ppstack_test/psModules/src/detrend/pmBias.c

@@ -154 +154 @@
     if (threaded) {
         // wait here for the threaded jobs to finish
-        if (!psThreadPoolWait(true)) {
+        if (!psThreadPoolWait(true, true)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to apply bias correction.");
             return false;

branches/meh_branches/ppstack_test/psModules/src/detrend/pmDark.c

@@ -601 +601 @@
     if (threaded) {
         // wait here for the threaded jobs to finish
-        if (!psThreadPoolWait(true)) {
+        if (!psThreadPoolWait(true, true)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to apply dark.");
             psFree(orders);

branches/meh_branches/ppstack_test/psModules/src/detrend/pmFlatField.c

@@ -161 +161 @@
     if (threaded) {
         // wait here for the threaded jobs to finish
-        if (!psThreadPoolWait(true)) {
+        if (!psThreadPoolWait(true, true)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to flat-field image.");
             return false;

branches/meh_branches/ppstack_test/psModules/src/detrend/pmPattern.c

@@ -6 +6 @@
 
 #include "pmPattern.h"
+
+#define PATTERN_ROW_BKG_FIX 1
 
 
@@ -89 +91 @@
     psImageInit(corr, NAN);
 
+#ifdef PATTERN_ROW_BKG_FIX
+    // CZW: 2011-11-30
+    // Define the vectors to hold the "x" and "y" slope trends.
+    // Briefly, the slope trend in the y-axis is a due to variations in the 0-th order term
+    // of the PATTERN.ROW fit between individual rows across the cell.  Similarly, the 1-st
+    // order term of the PATTERN.ROW fit defines the trend in the x-axis (as that's what we
+    // are fitting with PATTERN.ROW in the first place).  However, the thing we're trying to
+    // fix with PATTERN.ROW is the detector level bias wiggles.  These should be overlaid on
+    // the true sky level.  Therefore, simply applying the PATTERN.ROW correction will
+    // introduce cell-to-cell sky variations as these two trends are removed.  To avoid this,
+    // We store the 0th and 1st order values used for each row, and then fit a polynomial to
+    // these results.  By re-adding these systematic trends back, we can remove the row-to-row
+    // variations without improperly removing the real sky trend.
+    psVector *yaxisData = psVectorAlloc(numRows, PS_TYPE_F32); // Data to fit to the constant term
+    psVector *yaxisMask = psVectorAlloc(numRows, PS_TYPE_VECTOR_MASK); // Mask for rows with no fit
+    psVector *xaxisData = psVectorAlloc(numRows, PS_TYPE_F32); // Data to fit to the linear term
+    psVectorInit(yaxisMask, 0);
+#endif
     for (int y = 0; y < numRows; y++) {
         psVectorInit(clipMask, 0);
@@ -105 +125 @@
             // Not enough points to fit
             patternMaskRow(ro, y, maskBad);
+#ifdef PATTERN_ROW_BKG_FIX
+            // Ignore this row in our subsequent fits, because the fit failed.
+            yaxisMask->data.PS_TYPE_VECTOR_MASK_DATA[y] = 0xFF;
+#endif
             continue;
         }
@@ -111 +135 @@
             psErrorClear();
             patternMaskRow(ro, y, maskBad);
-            continue;
-        }
-
-        poly->coeff[0] -= background;
+#ifdef PATTERN_ROW_BKG_FIX
+            // Ignore this row in our subsequent fits, because the fit failed.
+            yaxisMask->data.PS_TYPE_VECTOR_MASK_DATA[y] = 0xFF;
+#endif
+            continue;
+        }
+#ifndef PATTERN_ROW_BKG_FIX
+        poly->coeff[0] -= background;
+#else
+        // Store the results we found for this row.
+        yaxisData->data.F32[y] = poly->coeff[0];
+        xaxisData->data.F32[y] = poly->coeff[1];
+        psTrace("pattern",1,"%d %g %g\n",y,poly->coeff[0],poly->coeff[1]);
+        
+        //      yaxisData->data.F32[y] = 0.0;
+/*      xaxisData->data.F32[y] = 0.0; */
+        
+#endif
         memcpy(corr->data.F64[y], poly->coeff, (order + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_F64));
         psVector *solution = psPolynomial1DEvalVector(poly, indices); // Solution vector
@@ -121 +159 @@
             psErrorClear();
             patternMaskRow(ro, y, maskBad);
+#ifdef PATTERN_ROW_BKG_FIX
+            yaxisMask->data.PS_TYPE_VECTOR_MASK_DATA[y] = 0xFF;
+#endif
             continue;
         }
@@ -126 +167 @@
         for (int x = 0; x < numCols; x++) {
             image->data.F32[y][x] -= solution->data.F32[x];
+            psTrace("pattern",5,"A: %d %d %g\n",x,y,solution->data.F32[x]);
         }
         psFree(solution);
     }
 
+#ifdef PATTERN_ROW_BKG_FIX
+    // Put the global trends back that were removed by the PATTERN.ROW correction.
+    // Set up the indices for the polynomial
+    psVector *yaxisIndices = psVectorAlloc(numRows, PS_TYPE_F32);
+    norm = 2.0 / (float)numRows;
+    for (int y = 0; y < numRows; y++) {
+      yaxisIndices->data.F32[y] = y * norm - 1.0;
+      psTrace("psModules.detrend.pattern",10,"%d %f %f\n",y,yaxisIndices->data.F32[y],yaxisData->data.F32[y]);
+    }
+
+    // Fit the trend of the constant term, producing the y-axis global trend
+    psStatsInit(clip);
+    psPolynomial1D *yaxisPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 1); // Polynomial to fit.
+    if (!psVectorClipFitPolynomial1D(yaxisPoly,clip,yaxisMask,0xFF,yaxisData, NULL, yaxisIndices)) {
+      psWarning("Unable to fit polynomial to y-axis trend");
+      psErrorClear();
+      // If we've failed, we need to do something, so add back in the background level, and
+      // expect that the final image will have background mismatches.
+      for (int y = 0; y < numRows; y++) {
+        for (int x = 0; x < numCols; x++) {
+          image->data.F32[y][x] += background;
+          corr->data.F64[y][0]  -= background;
+        }
+      }
+    }
+    else {
+      psVector *solution = psPolynomial1DEvalVector(yaxisPoly,yaxisIndices);
+      if (!solution) {
+        psWarning("Unable to evaluate polynomial");
+        psErrorClear();
+        // If we've failed, we need to do something, so add back in the background level, and
+        // expect that the final image will have background mismatches.
+        for (int y = 0; y < numRows; y++) {
+          for (int x = 0; x < numCols; x++) {
+            image->data.F32[y][x] += background;
+            corr->data.F64[y][0]  -= background;
+          }
+        }
+      }
+      else {
+        for (int y = 0; y < numRows; y++) {
+          for (int x = 0; x < numCols; x++) {
+            image->data.F32[y][x] += solution->data.F32[y];
+            corr->data.F64[y][0]  -= solution->data.F32[y];
+            psTrace("pattern",5,"B: %d %d %g\n",x,y,solution->data.F32[x]);
+          }
+        }
+      }
+      psFree(solution);
+    }      
+
+    // Fit the trend of the linear term, producing the x-axis global trend
+    // We can use the same mask vector, as the same rows failed the row-fit earlier.
+    psStatsInit(clip);
+    psPolynomial1D *xaxisPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 1); // Polynomial to fit.
+    if (!psVectorClipFitPolynomial1D(xaxisPoly,clip,yaxisMask,0xFF,xaxisData, NULL, yaxisIndices)) {
+      psWarning("Unable to fit polynomial to x-axis trend");
+      psErrorClear();
+    }
+    else {
+      psVector *solution = psPolynomial1DEvalVector(xaxisPoly,yaxisIndices);
+      if (!solution) {
+        psWarning("Unable to evaluate polynomial");
+        psErrorClear();
+      }
+      else {
+        for (int y = 0; y < numRows; y++) {
+          for (int x = 0; x < numCols; x++) {
+            image->data.F32[y][x] += solution->data.F32[y] * indices->data.F32[x];
+            corr->data.F64[y][1]  -= solution->data.F32[y] ;
+            psTrace("pattern",5,"C: %d %d %g %g\n",x,y,solution->data.F32[x],indices->data.F32[x]);
+          }
+        }
+      }
+      psFree(solution);
+    }
+    psFree(yaxisPoly);
+    psFree(xaxisPoly);
+    psFree(yaxisIndices);
+    psFree(yaxisMask);
+    psFree(yaxisData);
+    psFree(xaxisData);
+    // End PATTERN_ROW_BKG_FIX global trend replacement
+#endif 
+    
     psMetadataAddImage(ro->analysis, PS_LIST_TAIL, PM_PATTERN_ROW_CORRECTION, PS_META_REPLACE,
                        "Pattern row correction", corr);
@@ -382 +509 @@
 
 
+
+bool pmPatternContinuity(pmChip *chip, const psVector *tweak, psStatsOptions bgStat, psStatsOptions cellStat,
+                         psImageMaskType maskVal, psImageMaskType maskBad, int edgeWidth)
+{
+    PS_ASSERT_PTR_NON_NULL(chip, false);
+    PS_ASSERT_VECTOR_NON_NULL(tweak, false);
+    PS_ASSERT_VECTOR_SIZE(tweak, chip->cells->n, false);
+    PS_ASSERT_VECTOR_TYPE(tweak, PS_TYPE_U8, false);
+
+    int numCells = tweak->n;            // Number of cells
+
+    psVector *meanMask = psVectorAlloc(numCells, PS_TYPE_VECTOR_MASK); // Mask for means
+    psVectorInit(meanMask, 0);
+
+    // Mask bits
+    enum {
+        PM_PATTERN_IGNORE = 0x01,       // Ignore this cell
+        PM_PATTERN_TWEAK  = 0x02,       // Tweak this cell
+        PM_PATTERN_ERROR  = 0x04,       // Error in calculating background
+        PM_PATTERN_ALL    = 0xFF,       // All causes
+    };
+
+    // Count number of cells to tweak
+    int numTweak = 0;                   // Number of cells to tweak
+    int numIgnore = 0;                  // Number of cells to ignore
+    for (int i = 0; i < numCells; i++) {
+        pmCell *cell = chip->cells->data[i]; // Cell of interest
+        if (!cell || !cell->data_exists || !cell->process ||
+            cell->readouts->n == 0 || cell->readouts->n > 1 || !cell->readouts->data[0]) {
+            numIgnore++;
+            meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PM_PATTERN_IGNORE;
+            continue;
+        }
+        if (tweak->data.U8[i]) {
+            meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PM_PATTERN_TWEAK;
+            numTweak++;
+        }
+    }
+    if (numTweak == 0) {
+        // Nothing to do
+        psFree(meanMask);
+        return true;
+    }
+
+    // Measure mean of each cell edge, and use that to determine the cell offsets.
+
+    psStats *bgStats = psStatsAlloc(bgStat); // Statistics on background
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
+
+    psRegion region = {0,0,0,0};
+
+    /* These images hold the edge data for the OTA structure.  */
+    psImage *A = psImageAlloc(8,8,PS_TYPE_F64); // Top edge
+    psImage *B = psImageAlloc(8,8,PS_TYPE_F64); // Bottom edge
+    psImage *C = psImageAlloc(8,8,PS_TYPE_F64); // Right edge
+    psImage *D = psImageAlloc(8,8,PS_TYPE_F64); // Left edge
+    psImageInit(A,0.0);
+    psImageInit(B,0.0);
+    psImageInit(C,0.0);
+    psImageInit(D,0.0);
+    
+    for (int i = 0; i < numCells; i++) {
+        if (meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PM_PATTERN_IGNORE) {
+            continue;
+        }
+        pmCell *cell = chip->cells->data[i]; // Cell of interest
+        pmReadout *ro = cell->readouts->data[0]; // Readout of interest
+
+        psStatsInit(bgStats);
+
+        // Convert cell iterator i into an xy coordinate on the grid of cells
+        int y = (i % 8);
+        int x = (i - y) / 8;
+        
+        for (int j = 0; j < 4; j++) {
+          if (j == 0) {  // Region B
+            region = psRegionSet(0,ro->image->numCols,
+                                 0,edgeWidth);
+          }
+          else if (j == 1) { // Region A
+            region = psRegionSet(0,ro->image->numCols,
+                                 ro->image->numRows - edgeWidth,ro->image->numRows);
+          }
+          else if (j == 2) { // Region D
+            region = psRegionSet(0,edgeWidth,
+                                 0,ro->image->numRows);
+          }
+          else if (j == 3) { // Region C
+            region = psRegionSet(ro->image->numCols - edgeWidth,ro->image->numCols,
+                                 0,ro->image->numRows);
+          }
+          psImage *subset  = psImageSubset(ro->image,region);
+          psImage *submask = psImageSubset(ro->mask,region);
+
+          if (!psImageBackground(bgStats, NULL, subset, submask, maskVal, rng)) {
+            psWarning("Unable to measure background for cell %d on edge %d\n", i, j);
+            psErrorClear();
+            meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] |= PM_PATTERN_ERROR;
+            if (j == 0)      { B->data.F64[y][x] = NAN; }
+            else if (j == 1) { A->data.F64[y][x] = NAN; }
+            else if (j == 2) { C->data.F64[y][x] = NAN; }
+            else if (j == 3) { D->data.F64[y][x] = NAN; }
+            psFree(subset);
+            psFree(submask);
+            continue; // Move on to next edge, as only part of this cell may be a problem
+          }
+ 
+          // If the returned value is zero, assume something is wrong.  Do I still need this?
+          if (psStatsGetValue(bgStats,bgStat) < 1e-6) {
+            if (j == 0)      { B->data.F64[y][x] = NAN; }
+            else if (j == 1) { A->data.F64[y][x] = NAN; }
+            else if (j == 2) { C->data.F64[y][x] = NAN; }
+            else if (j == 3) { D->data.F64[y][x] = NAN; }
+          }
+          // If we have an error for this cell/edge, make sure we mask the value
+          if (meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PM_PATTERN_ERROR) {
+            if (j == 0)      { B->data.F64[y][x] = NAN; }
+            else if (j == 1) { A->data.F64[y][x] = NAN; }
+            else if (j == 2) { C->data.F64[y][x] = NAN; }
+            else if (j == 3) { D->data.F64[y][x] = NAN; }
+          }
+          else { // Set the value to match what we got from the edge box.
+            if (j == 0)      { B->data.F64[y][x] = psStatsGetValue(bgStats,bgStat); }
+            else if (j == 1) { A->data.F64[y][x] = psStatsGetValue(bgStats,bgStat); }
+            else if (j == 2) { C->data.F64[y][x] = psStatsGetValue(bgStats,bgStat); }
+            else if (j == 3) { D->data.F64[y][x] = psStatsGetValue(bgStats,bgStat); }
+          }
+
+          for (int u = 0; u < subset->numCols; u++) {
+            for (int v = 0; v < subset->numRows; v++) {
+              psTrace("psModules.detrend.cont",10,"BOX: %d %d (%d %d) (%d %d) %f %d",
+                      i,j,x,y,u,v,subset->data.F32[v][u],submask->data.PS_TYPE_IMAGE_MASK_DATA[v][u]);
+            }
+          }       
+          
+          psFree(subset);
+          psFree(submask);
+
+        }
+        psTrace("psModules.detrend.cont",5, "OTA: %d (%d %d) A: %f B: %f C: %f D: %f",
+                i,x,y,
+                A->data.F64[y][x],B->data.F64[y][x],C->data.F64[y][x],D->data.F64[y][x]);               
+    }
+    psFree(bgStats);
+    psFree(rng);
+
+    // We've now allocated all the edge values, so we can now minimize the offsets.
+    // This involves solving the equation A x = b, where
+    // A is the (64x64 for GPC1) matrix containing the edges that match for each cell
+    // x is the solution vector
+    // b is the combination of offsets across each cell boundary for each cell.
+    // Below "XX" is used as the matrix A, and "solution" is used as both b and x
+    //   (due to the way psMatrixLUSolve operates).
+    psVector *solution = psVectorAlloc(64,PS_TYPE_F64);
+    psImage  *XX       = psImageAlloc(64,64,PS_TYPE_F64);
+    psVectorInit(solution,0.0);
+    psImageInit(XX,0.0);
+    
+    for (int i = 0; i < numCells; i++) {
+      // Accumulate all the possible edge differences we can for this cell.
+      // As we do so, make a note of the correlations by incrementing the element of the matrix.
+      int y = (i % 8);
+      int x = (i - y) / 8;
+      int j;
+      double critical_value = 0.0;
+      if (meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PM_PATTERN_IGNORE) {
+        continue;
+      }
+      if (x + 1 < 8) {  // We have a neighbor adjacent in the +x direction
+        j = 8 * (x + 1) + y; // Determine that neighbor's index
+        if (fabs(C->data.F64[y][x]) > fabs(D->data.F64[y][x+1])) {
+          critical_value = 2.0 * fabs(D->data.F64[y][x+1]);
+        }
+        else {
+          critical_value = 2.0 * fabs(C->data.F64[y][x]);
+        }
+        if (critical_value < 25) { critical_value = 25; }
+        psTrace("psModules.detrend.cont",5,"CmD %d %d %d %d %g %g %g", // diagnostic
+                i,x,y,j,
+                C->data.F64[y][x],
+                D->data.F64[y][x+1],
+                critical_value
+                );
+        if (!(meanMask->data.PS_TYPE_VECTOR_MASK_DATA[j] & PM_PATTERN_IGNORE)&&  // If there are no errors with the neighbor,
+            (isfinite(C->data.F64[y][x]))&&(isfinite(D->data.F64[y][x+1]))&&     // and all edges have valid values,
+            (fabs(C->data.F64[y][x] - D->data.F64[y][x+1]) < critical_value)     // and there are no large discontinuities,
+            ) {    
+          solution->data.F64[i] += C->data.F64[y][x] - D->data.F64[y][x+1];     // Take the difference
+          XX->data.F64[i][i] += 1;                                              // increment our relation with ourself
+          XX->data.F64[i][j] += -1;                                             // decrement our relation with the neighbor
+        }
+      }
+      if (x - 1 > -1) { // etc.
+        j = 8 * (x - 1) + y;
+        if (fabs(C->data.F64[y][x-1]) > fabs(D->data.F64[y][x])) {
+          critical_value = 2.0 * fabs(D->data.F64[y][x]);
+        }
+        else {
+          critical_value = 2.0 * fabs(C->data.F64[y][x-1]);
+        }
+        if (critical_value < 25) { critical_value = 25; }
+        psTrace("psModules.detrend.cont",5,"DmC %d %d %d %d %g %g %g",
+                i,x,y,j,
+                D->data.F64[y][x],
+                C->data.F64[y][x-1],
+                critical_value
+                );
+
+        if (!(meanMask->data.PS_TYPE_VECTOR_MASK_DATA[j] & PM_PATTERN_IGNORE)&&
+            (isfinite(D->data.F64[y][x]))&&(isfinite(C->data.F64[y][x-1]))&&
+            (fabs(D->data.F64[y][x] - C->data.F64[y][x-1]) < critical_value)
+            ) {
+          solution->data.F64[i] += D->data.F64[y][x] - C->data.F64[y][x-1];
+          XX->data.F64[i][i] += 1;
+          XX->data.F64[i][j] += -1;
+        }
+      }
+      if (y + 1 < 8) {
+        j = 8 * x + (y + 1);
+        psTrace("psModules.detrend.cont",5,"AmB %d %d %d %d %g %g",
+                i,x,y,j,
+                A->data.F64[y][x],
+                B->data.F64[y+1][x]
+                );
+        if (fabs(A->data.F64[y][x]) > fabs(B->data.F64[y+1][x])) {
+          critical_value = 2.0 * fabs(B->data.F64[y+1][x]);
+        }
+        else {
+          critical_value = 2.0 * fabs(A->data.F64[y][x]);
+        }
+        if (critical_value < 25) { critical_value = 25; }
+        if (!(meanMask->data.PS_TYPE_VECTOR_MASK_DATA[j] & PM_PATTERN_IGNORE)&&
+            (isfinite(A->data.F64[y][x]))&&(isfinite(B->data.F64[y+1][x]))&&
+            (fabs(A->data.F64[y][x] - B->data.F64[y+1][x]) < critical_value)
+            ) {
+          solution->data.F64[i] += A->data.F64[y][x] - B->data.F64[y+1][x];
+          XX->data.F64[i][i] += 1;
+          XX->data.F64[i][j] += -1;
+        }
+      }
+      if (y - 1 > -1) {
+        j = 8 * x +  (y - 1);
+        psTrace("psModules.detrend.cont",5,"BmA %d %d %d %d %g %g",
+                i,x,y,j,
+                B->data.F64[y][x],
+                A->data.F64[y-1][x]
+                );
+        if (fabs(A->data.F64[y-1][x]) > fabs(B->data.F64[y][x])) {
+          critical_value = 2.0 * fabs(B->data.F64[y][x]);
+        }
+        else {
+          critical_value = 2.0 * fabs(A->data.F64[y-1][x]);
+        }
+        if (critical_value < 25) { critical_value = 25; }
+        if (!(meanMask->data.PS_TYPE_VECTOR_MASK_DATA[j] & PM_PATTERN_IGNORE)&&
+            (isfinite(B->data.F64[y][x]))&&(isfinite(A->data.F64[y-1][x]))&&
+            (fabs(B->data.F64[y][x] - A->data.F64[y-1][x]) < critical_value)
+            ) {
+          solution->data.F64[i] += B->data.F64[y][x] - A->data.F64[y-1][x];
+          XX->data.F64[i][i] += 1;
+          XX->data.F64[i][j] += -1;
+        }
+      }
+    }
+    double max_XX = 0;
+    double solution_V = 0;
+    int i_peak = -1;
+    for (int i = 0; i < numCells; i++) { // If any cells have no value of themself, set the matrix to 1.0.
+      if (XX->data.F64[i][i] == 0.0) {
+        XX->data.F64[i][i] = 1.0;
+      }
+      if (XX->data.F64[i][i] > max_XX) {
+        max_XX = XX->data.F64[i][i];
+        solution_V = solution->data.F64[i];
+        i_peak = i;
+      }
+    }
+    psTrace("psModules.detrend.cont",5,"fixed point: %d %g\n",
+            i_peak,solution_V);
+
+    for (int i = 0; i < numCells; i++) {
+/*        if (!((XX->data.F64[i][i] == 1.0)&& */
+/*          (solution->data.F64[i] == 0.0))) { */
+        solution->data.F64[i] -= solution_V;
+        if (i != i_peak) {
+          for (int j = 0; j < numCells; j++) {
+            XX->data.F64[i][j] -= XX->data.F64[i_peak][j];
+          }
+        }
+/*        } */
+    }
+    for (int i = 0; i < numCells; i++) {
+      XX->data.F64[i_peak][i] = 0.0;
+    }
+    XX->data.F64[i_peak][i_peak] = 1.0;
+    
+    
+#if (1)
+    for (int i = 0; i < numCells; i++) { // print matrix A
+      psTrace("psModules.detrend.cont",5,"A: %3d % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f % 2.0f",
+              i,
+              XX->data.F64[i][0],             XX->data.F64[i][1],             XX->data.F64[i][2],             XX->data.F64[i][3],
+              XX->data.F64[i][4],             XX->data.F64[i][5],             XX->data.F64[i][6],             XX->data.F64[i][7],
+              XX->data.F64[i][8],             XX->data.F64[i][9],             XX->data.F64[i][10],            XX->data.F64[i][11],
+              XX->data.F64[i][12],            XX->data.F64[i][13],            XX->data.F64[i][14],            XX->data.F64[i][15],
+              XX->data.F64[i][16],            XX->data.F64[i][17],            XX->data.F64[i][18],            XX->data.F64[i][19],
+              XX->data.F64[i][20],            XX->data.F64[i][21],            XX->data.F64[i][22],            XX->data.F64[i][23],
+              XX->data.F64[i][24],            XX->data.F64[i][25],            XX->data.F64[i][26],            XX->data.F64[i][27],
+              XX->data.F64[i][28],            XX->data.F64[i][29],            XX->data.F64[i][30],            XX->data.F64[i][31],
+              XX->data.F64[i][32],            XX->data.F64[i][33],            XX->data.F64[i][34],            XX->data.F64[i][35],
+              XX->data.F64[i][36],            XX->data.F64[i][37],            XX->data.F64[i][38],            XX->data.F64[i][39],
+              XX->data.F64[i][40],            XX->data.F64[i][41],            XX->data.F64[i][42],            XX->data.F64[i][43],
+              XX->data.F64[i][44],            XX->data.F64[i][45],            XX->data.F64[i][46],            XX->data.F64[i][47],
+              XX->data.F64[i][48],            XX->data.F64[i][49],            XX->data.F64[i][50],            XX->data.F64[i][51],
+              XX->data.F64[i][52],            XX->data.F64[i][53],            XX->data.F64[i][54],            XX->data.F64[i][55],
+              XX->data.F64[i][56],            XX->data.F64[i][57],            XX->data.F64[i][58],            XX->data.F64[i][59],
+              XX->data.F64[i][60],            XX->data.F64[i][61],            XX->data.F64[i][62],            XX->data.F64[i][63]
+              );
+    }
+
+    for (int i = 0; i < numCells; i++) { // print vector b
+      psTrace("psModules.detrend.cont",5,"b: %d %f",
+              i,
+              solution->data.F64[i]
+              );
+    }
+#endif    
+    
+    // Solve the Ax=b equation
+    //    psMatrixLUSolve(XX,solution);
+    psMatrixGJSolve(XX,solution);
+#if (1)
+    for (int i = 0; i < numCells; i++) { // print vector b
+      psTrace("psModules.detrend.cont",5,"x: %d %f",
+              i,
+              solution->data.F64[i]
+              );
+    }
+#endif
+    
+    /* old code to remove the minimum solution value from the set, to give a "minimal set of offsets." Mathematically unnecessary. */
+/*     double min = 99e99; */
+/*     for (int i = 0; i < numCells; i++) { */
+/*       if (solution->data.F64[i] < min) { */
+/*      min = solution->data.F64[i]; */
+/*       } */
+/*       psTrace("psModules.detrend.cont",5,"x: %d %f %f ", */
+/*            i, */
+/*            solution->data.F64[i],min */
+/*            ); */
+/*     } */
+/*     for (int i = 0; i < numCells; i++) { */
+/*      if (solution->data.F64[i] != 0.0) { */
+/*        solution->data.F64[i] -= min; */
+/*      } */
+/*     } */
+
+    // Cleanup
+    psFree(XX);
+    psFree(A);
+    psFree(B);
+    psFree(C);
+    psFree(D);
+
+    // Correct cells based on the offsets calculated, and store the result in the analysis metadata.
+    for (int i = 0; i < numCells; i++) {
+        if (meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PM_PATTERN_IGNORE) {
+            continue;
+        }
+        if (!(meanMask->data.PS_TYPE_VECTOR_MASK_DATA[i] & PM_PATTERN_TWEAK)) {
+            continue;
+        }
+        pmCell *cell = chip->cells->data[i]; // Cell of interest
+        pmReadout *ro = cell->readouts->data[0]; // Readout of interest
+
+        float correction = solution->data.F64[i];
+        const char *cellName = psMetadataLookupStr(NULL, cell->concepts, "CELL.NAME"); // Name of cell
+        psLogMsg("psModules.detrend", PS_LOG_DETAIL, "Correcting background of cell %s by %f",
+                 cellName, correction);
+        psBinaryOp(ro->image, ro->image, "-", psScalarAlloc(correction, PS_TYPE_F32));
+        psMetadataAddF32(ro->analysis, PS_LIST_TAIL, PM_PATTERN_CELL_CORRECTION, PS_META_REPLACE,
+                         "Pattern cell correction solution", correction);
+    }
+
+    psFree(solution);
+    psFree(meanMask);
+
+    return true;
+}
+
+bool pmPatternContinuityApply(pmReadout *ro, psImageMaskType maskBad)
+{
+    PM_ASSERT_READOUT_NON_NULL(ro, false);
+    PM_ASSERT_READOUT_IMAGE(ro, false);
+
+    bool mdok;                          // Status of MD lookup
+    float corr = psMetadataLookupF32(&mdok, ro->analysis, PM_PATTERN_CELL_CORRECTION); // Correction to apply
+    if (!mdok) {
+        // No correction to apply
+        return true;
+    }
+
+    psImage *image = ro->image, *mask = ro->mask; // Image and mask of interest
+    int numCols = image->numCols, numRows = image->numRows; // Size of image
+
+    if (!isfinite(corr)) {
+        for (int y = 0; y < numRows; y++) {
+            for (int x = 0; x < numCols; x++) {
+                image->data.F32[y][x] = NAN;
+            }
+        }
+        if (mask) {
+            for (int y = 0; y < numRows; y++) {
+                for (int x = 0; x < numCols; x++) {
+                    mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= maskBad;
+                }
+            }
+        }
+    } else {
+        for (int y = 0; y < numRows; y++) {
+            for (int x = 0; x < numCols; x++) {
+                image->data.F32[y][x] += corr;
+            }
+        }
+    }
+
+    return true;
+}
+
+

branches/meh_branches/ppstack_test/psModules/src/detrend/pmPattern.h

@@ -54 +54 @@
                         );
 
+/// Fix the background on cells known to be troublesome
+bool pmPatternContinuity(
+    pmChip *chip,                       ///< Chip to correct
+    const psVector *tweak,              ///< U8 vector indicating whether to tweak the corresponding cell
+    psStatsOptions bgStat,              ///< Statistic to use for background measurement
+    psStatsOptions cellStat,            ///< Statistic to use for combination of cell background measurements
+    psImageMaskType maskVal,            ///< Mask value to use
+    psImageMaskType maskBad,            ///< Mask value to give bad pixels
+    int edgeWidth                       ///< Size of box to use
+    );
+
+/// Apply previously measured cell pattern correction
+bool pmPatternContinuityApply(pmReadout *ro,          ///< Readout to correct
+                        psImageMaskType maskBad ///< Mask value to give bad pixels
+                        );
+
+
 
 /// @}

branches/meh_branches/ppstack_test/psModules/src/detrend/pmShutterCorrection.c

@@ -805 +805 @@
         if (threaded) {
             // wait here for the threaded jobs to finish
-            if (!psThreadPoolWait(true)) {
+            if (!psThreadPoolWait(true, true)) {
                 psError(PS_ERR_UNKNOWN, false, "Unable to apply shutter correction.");
                 psFree(shutterImage);

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmPSFEnvelope.c

@@ -36 +36 @@
 
 
-//#define TESTING                         // Enable test output
+#define TESTING                         // Enable test output
 // #define PEAK_NORM                       // Normalise peaks?
 #define PEAK_FLUX 1.0e4                 // Peak flux for each source
@@ -380 +380 @@
 
         // measure the source moments: tophat windowing, no pixel S/N cutoff
-        if (!pmSourceMoments(source, maxRadius, 0.0, 0.0, 0.0, maskVal)) {
+        if (!pmSourceMoments(source, maxRadius, 0.25*maxRadius, 0.0, 0.0, maskVal)) {
             // Can't do anything about it; limp along as best we can
             psErrorClear();

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmStackReject.c

@@ -313 +313 @@
     }
 
-    if (!psThreadPoolWait(false)) {
+    if (!psThreadPoolWait(false, true)) {
         psError(psErrorCodeLast(), false, "Unable to grow bad pixels.");
         psFree(source);

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmSubtraction.c

@@ -905 +905 @@
         }
     }
-    if (!psThreadPoolWait(true)) {
+    if (!psThreadPoolWait(true, true)) {
         psError(psErrorCodeLast(), false, "Error waiting for threads.");
         return false;
@@ -1019 +1019 @@
                 }
             }
-            pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "red");
+
+            psString ds9text = NULL;
+
+            psStringAppend(&ds9text, "flux: %.0f ", match->fluxes->data.F32[i]);
+            psStringAppend(&ds9text, "chi2: %.0f ", match->chisq->data.F32[i]);
+
+            pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "red", ds9text);
+
+            psFree(ds9text);       
 
             // Set stamp for replacement
@@ -1041 +1049 @@
         } else {
             numGood++;
-            pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "green");
+
+            //MEH bad way to do this - should also add to rej/red one as well
+            // -- is match from subQuality what want?
+            psString ds9text = NULL;
+
+            psStringAppend(&ds9text, "flux: %.0f ", match->fluxes->data.F32[i]);
+            psStringAppend(&ds9text, "chi2: %.0f ", match->chisq->data.F32[i]);
+
+            pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "green", ds9text);
+
+            psFree(ds9text);       
         }
     }
@@ -1427 +1445 @@
     }
 
-    if (!psThreadPoolWait(false)) {
+    if (!psThreadPoolWait(false, true)) {
         psError(psErrorCodeLast(), false, "Error waiting for threads.");
         return false;
@@ -1487 +1505 @@
             }
         }
+        psFree(out1->covariance);
         out1->covariance = psImageCovarianceAverage(covars);
         psFree(covars);
@@ -1527 +1546 @@
             }
         }
+        psFree(out2->covariance);
         out2->covariance = psImageCovarianceAverage(covars);
         psFree(covars);

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmSubtractionEquation.c

@@ -796 +796 @@
     stamp->normSquare1 = normSquare1;
     stamp->normSquare2 = normSquare2;
-
-    // psLogMsg ("psModules.imcombine", PS_LOG_DETAIL, "normValue: %f %f %f  (%f %f)\n", normI1, normI2, stamp->norm, normSquare1, normSquare2);
+    
+    //psLogMsg ("psModules.imcombine", PS_LOG_DETAIL, "normValue: %f %f %f  (%f %f)\n", normI1, normI2, stamp->norm, normSquare1, normSquare2);
 
     return true;
@@ -958 +958 @@
     }
 
-    if (!psThreadPoolWait(true)) {
+    if (!psThreadPoolWait(true, true)) {
         psError(psErrorCodeLast(), false, "Error waiting for threads.");
         return false;
@@ -1037 +1037 @@
                 (void)psBinaryOp(sumVector, sumVector, "+", stamp->vector);
 
-                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "green");
+                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "green", "");
                 numStamps++;
             } else if (stamp->status == PM_SUBTRACTION_STAMP_REJECTED) {
-                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "red");
+                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "red", "");
             }
         }
@@ -1139 +1139 @@
                 normSquare2 += stamp->normSquare2;
 
-                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "green");
+                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "green", "");
                 numStamps++;
             } else if (stamp->status == PM_SUBTRACTION_STAMP_REJECTED) {
-                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "red");
+                pmSubtractionStampPrint(ds9, stamp->x, stamp->y, stamps->footprint, "red", "");
             }
         }
@@ -1382 +1382 @@
         float Myy = fluxY2 / fluxC1;
 
+        //MEH uncomment and update
         // fprintf (stderr, "conv1, flux2: %f, Mx: %f, My: %f, Mxx: %f, Myy: %f, chisq: %f, npix: %d\n", flux2, Mx, My, Mxx, Myy, chisq, npix);
+        //fprintf (stderr, "conv1, flux2: %f, fluxC1: %f, Mxx: %f, Myy: %f, chisqR: %f, npix: %d\n", flux2, fluxC1, Mxx, Myy, chisqR, npix);
+
         moment += Mxx + Myy;
     }
@@ -1554 +1557 @@
                     residual->kernel[y][x] = difference->kernel[y][x] - convolved1->kernel[y][x];
                     convolved1->kernel[y][x] += source->kernel[y][x] * norm;
+                    //MEH 
+                    //psLogMsg("psModules.imcombine", PS_LOG_INFO, "xy: %d %d, norm: %6.3f, bg: %6.3f, difference: %6.3f, target: %6.3f, source: %6.3f, residual: %6.3f, convolved1: %6.3f \n",x,y,norm,background,difference->kernel[y][x],target->kernel[y][x],source->kernel[y][x],residual->kernel[y][x],convolved1->kernel[y][x]);
+
                 }
             }
@@ -1652 +1658 @@
     } else {
         sumKernel2 = 1.0;
-    }
+        //MEH
+        sumKernel2 = 0.001;
+    }
+    //MEH if sumKernel2 not use essentially, then not need to be 2.0*? but level of orderFactor may need to be adjusted then
 
     // if we modify the chisq value by the (sumKernel1 + sumKernel2), we account for the
@@ -1658 +1667 @@
     // penalized by increasing the score somewhat.  the 0.01 value is not well-chosen.
     float orderFactor = 0.01 * kernels->spatialOrder;
-    float score = 2.0 * chisqRValue / (sumKernel1 + sumKernel2) + orderFactor;
-    psLogMsg("psModules.imcombine", PS_LOG_INFO, "chisq: %6.3f, chisqD: %6.3f, moment: %6.3f, sumKernel_1: %6.3f, sumKernel_2, score: %6.3f: %6.3f\n", chisqRValue, chisqDValue, momentValue, sumKernel1, sumKernel2, score);
+    //MEH
+    //float score = 2.0 * chisqRValue / (sumKernel1 + sumKernel2) + orderFactor;
+    float score = 2.0 * chisqRValue / (sqrt(sumKernel1) + sqrt(sumKernel2)) + orderFactor;
+    psLogMsg("psModules.imcombine", PS_LOG_INFO, "chisq: %6.3f, chisqD: %6.3f, moment: %6.3f, sumKernel_1: %6.3f, sumKernel_2: %6.3f, score: %6.3f\n", chisqRValue, chisqDValue, momentValue, sumKernel1, sumKernel2, score);
 
     // save this result if it is the first or the best (skip if bestMatch is NULL)

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmSubtractionEquation.v0.c

@@ -882 +882 @@
     }
 
-    if (!psThreadPoolWait(true)) {
+    if (!psThreadPoolWait(true, true)) {
         psError(psErrorCodeLast(), false, "Error waiting for threads.");
         return false;

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmSubtractionMatch.c

@@ -29 +29 @@
 static bool useFFT = true;              // Do convolutions using FFT
 
-//#define TESTING
-//#define TESTING_MEMORY
+#define TESTING
+#define TESTING_MEMORY
 
 // Output memory usage information
@@ -538 +538 @@
     // Where does our variance map come from?
     // Getting the variance exactly right is not necessary --- it's just used for weighting.
+    // MEH - helpful to have one used output to log -- at some level want log output for most every step
+
     psImage *variance = NULL;             // Variance image to use
     if (ro1->variance && ro2->variance) {
         variance = (psImage*)psBinaryOp(NULL, ro1->variance, "+", ro2->variance);
+        psLogMsg("psModules.imcombine", PS_LOG_DETAIL, "TESTING:SubMatch variance avail: var1+var2");
     } else if (ro1->variance) {
         variance = psMemIncrRefCounter(ro1->variance);
+        psLogMsg("psModules.imcombine", PS_LOG_DETAIL, "TESTING:SubMatch variance avail: var1");
     } else if (ro2->variance) {
         variance = psMemIncrRefCounter(ro2->variance);
+        psLogMsg("psModules.imcombine", PS_LOG_DETAIL, "TESTING:SubMatch variance avail: var2");
     } else {
         variance = (psImage*)psBinaryOp(NULL, ro1->image, "+", ro2->image);
-    }
+        psLogMsg("psModules.imcombine", PS_LOG_DETAIL, "TESTING:SubMatch variance avail: none ro1+ro2");
+    }
+
 
     // Putting important variable declarations here, since they are freed after a "goto" if there is an error.
@@ -726 +733 @@
                 float radMoment1 = stamps->normWindow1 / 2.75;
                 float radMoment2 = stamps->normWindow2 / 2.75;
+                //MEH - FWHM vs radialMoment need *2? may mess up other parts
+                //float radMoment1 = stamps->normWindow1 / 2.75*2;
+                //float radMoment2 = stamps->normWindow2 / 2.75*2;
                 pmSubtractionParamsScale(NULL, NULL, isisWidths, radMoment1, radMoment2);
 
@@ -810 +820 @@
                     }
                 }
-
+                //MEH probably should comment out but should be ok?
                 // step 0 : calculate the normalizations, pass along to the next steps via stamps->normValue
                 psTrace("psModules.imcombine", 3, "Calculating normalization...\n");
@@ -825 +835 @@
                 for (int order = 0; order <= N_TEST_ORDER; order++) {
                     for (int j = 0; j < N_TEST_MODES; j++) {
+                        //MEH: thinking pmSubtractionCalculateNormalization needs to be called here for conv source
+                        // per mode
+                        //psTrace("psModules.imcombine", 3, "Calculating normalization...order: %d  mode: %d\n",order,j);
+                        //                        if (!pmSubtractionCalculateNormalization(stamps, TestModes[j])) {
+                        //    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
+                        //    goto MATCH_ERROR;
+                        //}
+                        //
                         if (!pmSubtractionMatchAttempt(&bestMatch, kernels, stamps, TestModes[j], order, false)) {
                             goto MATCH_ERROR;
@@ -843 +861 @@
             // apply the best fit so we are ready to roll
             psLogMsg("psModules.imcombine", PS_LOG_INFO, "applying order: %d, mode: %d\n", bestMatch->spatialOrder, bestMatch->mode);
+            //MEH need to call normalization one more time for final/best run - 
+            // but what if dual - already checked for in pmSubtractionCalculateNormalization
+            //if (!pmSubtractionCalculateNormalization(stamps, bestMatch->mode)) {
+            //    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
+            //    goto MATCH_ERROR;
+            //}
+            // 
             if (!pmSubtractionMatchAttempt(NULL, kernels, stamps, bestMatch->mode, bestMatch->spatialOrder, true)) {
                 goto MATCH_ERROR;
@@ -1091 +1116 @@
     }
 
-    if (!psThreadPoolWait(true)) {
+    if (!psThreadPoolWait(true, true)) {
         psError(psErrorCodeLast(), false, "Error waiting for threads.");
         psFree(models);
@@ -1331 +1356 @@
         *stampSize = *stampSize * scale + 0.5;
     }
-
+    //MEH
+    psLogMsg("psModules.imcombine", PS_LOG_INFO, "TESTING Scaling kernel parameters fwhm1,2,refscale/min/max: %f %f %f %f %f", fwhm1,fwhm2,scaleRefOption,scaleMinOption,scaleMaxOption);
     psLogMsg("psModules.imcombine", PS_LOG_INFO, "Scaling kernel parameters by %f", scale);
     if (kernelSize) psLogMsg("psModules.imcombine", PS_LOG_INFO, " modified kernel size %d", *kernelSize);

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmSubtractionStamps.c

@@ -127 +127 @@
                 continue;
             }
+            //MEH hack to limit bright end test
+//            if ((image1 && image1->data.F32[y][x] > 2000) ||
+//                (image2 && image2->data.F32[y][x] > 2000 )) {
+//              fprintf (stderr, "%f,%f : thresh\n",image1->data.F32[y][x],image2->data.F32[y][x]);
+//                continue;
+//            }
 
             if (subMask && subMask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] &
@@ -188 +194 @@
 }
 
-void pmSubtractionStampPrint(FILE *ds9, float x, float y, float size, const char *color)
+// MEH adding text to ds9
+void pmSubtractionStampPrint(FILE *ds9, float x, float y, float size, const char *color, const char *ds9text)
 {
     if (!ds9regions || !ds9) {
@@ -196 +203 @@
     if (color && strlen(color) > 0) {
         fprintf(ds9, " # color=%s", color);
+    }
+    if (ds9text && strlen(ds9text) > 0) {
+        fprintf(ds9, " text={%s}", ds9text);
     }
     fprintf(ds9, "\n");
@@ -486 +496 @@
                                              normFrac, sysErr, skyErr);
     }
-
+    //MEH - stamps.dat will repeatedly be overwritten - out to trace may be btter -- see end for summary 
     // XXX TEST : dump all stars in the stamps here
-    if (0) {
+    if (1) {
         FILE *f = fopen ("stamp.dat", "w");
         for (int i = 0; i < stamps->num; i++) {
@@ -589 +599 @@
                 stamp->status = PM_SUBTRACTION_STAMP_FOUND;
                 numFound++;
-                psTrace("psModules.imcombine", 5, "Found stamp in subregion %d: %d,%d\n",
-                        i, (int)stamp->x, (int)stamp->y);
+//                psTrace("psModules.imcombine", 5, "Found stamp in subregion %d: %d,%d\n",
+//                        i, (int)stamp->x, (int)stamp->y);
+                //MEH adding int flux to say something about the source 
+                psTrace("psModules.imcombine", 5, "Found stamp in subregion %d: %d,%d  Flux: %d\n",
+                        i, (int)stamp->x, (int)stamp->y, (int)stamp->flux);
             } else {
                 stamp->status = PM_SUBTRACTION_STAMP_NONE;
@@ -666 +679 @@
             psTrace("psModules.imcombine", 9, "Rejecting input stamp (%d,%d) because outside region",
                     xPix, yPix);
-            pmSubtractionStampPrint(ds9, xPix, yPix, footprint, "red");
+            pmSubtractionStampPrint(ds9, xPix, yPix, footprint, "red", "");
             continue;
         }
-
+        //MEH - are all using -0.5? seen some seem shifted
         // fprintf (stderr, "stamp: %5.1f %5.1f == %d %d\n", xStamp, yStamp, xPix, yPix);
 
@@ -692 +705 @@
                 psTrace("psModules.imcombine", 9, "Putting input stamp (%d,%d) into subregion %d",
                         xPix, yPix, j);
-                pmSubtractionStampPrint(ds9, xPix, yPix, footprint, "green");
+                pmSubtractionStampPrint(ds9, xPix, yPix, footprint, "green", "");
             }
         }
@@ -699 +712 @@
             psTrace("psModules.imcombine", 9, "Unable to find subregion for stamp (%d,%d)",
                     xPix, yPix);
-            pmSubtractionStampPrint(ds9, xPix, yPix, footprint, "yellow");
+            pmSubtractionStampPrint(ds9, xPix, yPix, footprint, "yellow", "");
         }
     }
@@ -865 +878 @@
         }
     }
-
-#if 0
+//MEH
+#if 1
     {
         psFits *fits = NULL;
@@ -1156 +1169 @@
                 float sysErr = 0.25 * PS_SQR(stamps->sysErr); // Systematic error
                 float skyErr = stamps->skyErr;
+                //MEH - image2 not used if not adding to additional.. also these are never freed here, but upstream/downstream?
                 psKernel *image1 = stamp->image1, *image2 = stamp->image2; // Input images
+                //psKernel *image2 = stamp->image2; // Input images
                 for (int y = -size; y <= size; y++) {
                     for (int x = -size; x <= size; x++) {
+                        //MEH -- if conv to model then what does sys and weight mean for both?
+                        // w1+w2 vs 1/var1+1/var2.. depends on what the weight is for?
+                        // why additional ^2? 
                         float additional = image1->kernel[y][x] + image2->kernel[y][x];
-                        weight->kernel[y][x] = 1.0 / (skyErr + var->kernel[y][x] + sysErr * PS_SQR(additional));
+                        //float additional = image2->kernel[y][x];
+//                        weight->kernel[y][x] = 1.0 / (skyErr + var->kernel[y][x] + sysErr * PS_SQR(additional));
+                        weight->kernel[y][x] = 1.0 / (skyErr + 1000.0*var->kernel[y][x] + sysErr * PS_SQR(additional));
                     }
                 }
+                psLogMsg("psModules.imcombine", PS_LOG_DETAIL, "TESTING:: Stamp %d (%.1f,%.1f) weight: %f var: %.1f sysErr: %.2f im1: %.0f im2: %.0f \n", 
+                         i, stamp->x, stamp->y, weight->kernel[0][0],var->kernel[0][0],sysErr,image2->kernel[0][0],image1->kernel[0][0]);
+
             } else {
                 for (int y = -size; y <= size; y++) {
                     for (int x = -size; x <= size; x++) {
-                        weight->kernel[y][x] = 1.0 / var->kernel[y][x];
+//                        weight->kernel[y][x] = 1.0 / var->kernel[y][x];
+                        weight->kernel[y][x] = 1.0 / (1000.0*var->kernel[y][x]);
                     }
                 }

branches/meh_branches/ppstack_test/psModules/src/imcombine/pmSubtractionStamps.h

@@ -163 +163 @@
                              float x, float y, ///< Position of stamp
                              float size,///< Size of circle
-                             const char *color ///< Colour
+                             const char *color, ///< Colour
+                             const char *ds9text ///< info text
     );
-
+// MEH added text to ds9 file
 
 bool pmSubtractionStampsResetStatus (pmSubtractionStampList *stamps);

branches/meh_branches/ppstack_test/psModules/src/objects

@@ -5 +5 @@
 *.la
 *.lo
+pmSourceIO_CMF_PS1_V1.c
+pmSourceIO_CMF_PS1_V2.c
+pmSourceIO_CMF_PS1_V3.c
+pmSourceIO_CMF_PS1_V4.c
+pmSourceIO_CMF_PS1_V3.v1.c
+pmSourceIO_CMF_PS1_V1.v1.c
+pmSourceIO_CMF_PS1_V2.v1.c
+

@@ -5 +5 @@
 *.la
 *.lo
+pmSourceIO_CMF_PS1_V1.c
+pmSourceIO_CMF_PS1_V2.c
+pmSourceIO_CMF_PS1_V3.c
+pmSourceIO_CMF_PS1_V4.c
+pmSourceIO_CMF_PS1_V3.v1.c
+pmSourceIO_CMF_PS1_V1.v1.c
+pmSourceIO_CMF_PS1_V2.v1.c
+

branches/meh_branches/ppstack_test/psModules/src/objects/Makefile.am

@@ -45 +45 @@
         pmSourceIO_CMF_PS1_V2.c \
         pmSourceIO_CMF_PS1_V3.c \
+        pmSourceIO_CMF_PS1_V4.c \
         pmSourceIO_CMF_PS1_SV1.c \
         pmSourceIO_CMF_PS1_DV1.c \
@@ -130 +131 @@
 
 # pmSourceID_CMF_* functions use a common framework
-BUILT_SOURCES = pmSourceIO_CMF_PS1_V1.v1.c pmSourceIO_CMF_PS1_V2.v1.c pmSourceIO_CMF_PS1_V3.v1.c
+BUILT_SOURCES = pmSourceIO_CMF_PS1_V1.c pmSourceIO_CMF_PS1_V2.c pmSourceIO_CMF_PS1_V3.c pmSourceIO_CMF_PS1_V4.c
 
-pmSourceIO_CMF_PS1_V1.v1.c : pmSourceIO_CMF.c.in mksource.pl
-        mksource.pl pmSourceIO_CMF.c.in PS1_V1 pmSourceIO_CMF_PS1_V1.v1.c
+pmSourceIO_CMF_PS1_V1.c : pmSourceIO_CMF.c.in mksource.pl
+        mksource.pl pmSourceIO_CMF.c.in PS1_V1 pmSourceIO_CMF_PS1_V1.c
 
-pmSourceIO_CMF_PS1_V2.v1.c : pmSourceIO_CMF.c.in mksource.pl
-        mksource.pl pmSourceIO_CMF.c.in PS1_V2 pmSourceIO_CMF_PS1_V2.v1.c
+pmSourceIO_CMF_PS1_V2.c : pmSourceIO_CMF.c.in mksource.pl
+        mksource.pl pmSourceIO_CMF.c.in PS1_V2 pmSourceIO_CMF_PS1_V2.c
 
-pmSourceIO_CMF_PS1_V3.v1.c : pmSourceIO_CMF.c.in mksource.pl
-        mksource.pl pmSourceIO_CMF.c.in PS1_V2 pmSourceIO_CMF_PS1_V3.v1.c
+pmSourceIO_CMF_PS1_V3.c : pmSourceIO_CMF.c.in mksource.pl
+        mksource.pl pmSourceIO_CMF.c.in PS1_V3 pmSourceIO_CMF_PS1_V3.c
+
+pmSourceIO_CMF_PS1_V4.c : pmSourceIO_CMF.c.in mksource.pl
+        mksource.pl pmSourceIO_CMF.c.in PS1_V4 pmSourceIO_CMF_PS1_V4.c
 
 # EXTRA_DIST = pmErrorCodes.h.in pmErrorCodes.dat pmErrorCodes.c.in

branches/meh_branches/ppstack_test/psModules/src/objects/mksource.pl

@@ -14 +14 @@
 
 # see if we can add in PS1_DV* and PS1_SV* as well...
-@cmfmodes = ("PS1_V1", 1,
+%cmfmodes = ("PS1_V1", 1,
              "PS1_V2", 2,
-             "PS1_V3", 3);
+             "PS1_V3", 3,
+             "PS1_V4", 4);
+
+print "1: $cmfmodes{1}\n";
+print "PS1_V1: $cmfmodes{'PS1_V1'}\n";
 
 open (FILE, "$template") || die "failed to open template $template\n";
@@ -50 +54 @@
 
     if ($gtMode) {
+        # print "gtMode : $line\n";
         $thisLevel = $cmfmodes{$gtMode};
         $myLevel = $cmfmodes{$cmfmode};
-        if ($thisLevel <= $myLevel) { next; }
-        $line =~ s|\@<\S*\@\s*||;
+        print "gtMode : $gtMode vs $cmfmode, $thisLevel, $myLevel\n";
+        if ($myLevel <= $thisLevel) { next; }
+        $line =~ s|\@>\S*\@\s*||;
     }
 
     if ($ltMode) {
+        # print "ltMode : $line\n";
         $thisLevel = $cmfmodes{$ltMode};
         $myLevel = $cmfmodes{$cmfmode};
-        if ($thisLevel >= $myLevel) { next; }
-        $line =~ s|\@>\S*\@\s*||;
+        print "ltMode : $ltMode vs $cmfmode, $thisLevel, $myLevel\n";
+        if ($myLevel >= $thisLevel) { next; }
+        $line =~ s|\@<\S*\@\s*||;
     }
 

branches/meh_branches/ppstack_test/psModules/src/objects/models/pmModel_DEV.c

@@ -89 +89 @@
 static bool limitsApply = true;         // Apply limits?
 
+# include "pmModel_SERSIC.CP.h"
+
 psF32 PM_MODEL_FUNC (psVector *deriv,
                      const psVector *params,
@@ -94 +96 @@
 {
     psF32 *PAR = params->data.F32;
-
-    float index = 0.5 / ALPHA;
-    float bn = 1.9992*index - 0.3271;
-    float Io = exp(bn);
 
     psF32 X  = pixcoord->data.F32[0] - PAR[PM_PAR_XPOS];
@@ -105 +103 @@
     psF32 z  = (PS_SQR(px) + PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y);
 
-    assert (z >= 0);
+    // If the elliptical contour is defined in a valid way, we should never trigger this
+    // assert.  Other models (like PGAUSS) don't use fractional powers, and thus do not have
+    // NaN values for negative values of z
+    psAssert (z >= 0, "do not allow negative z values in model");
+
+    float index = 0.5 / ALPHA;
+    float par7 = ALPHA;
+    float bn = 1.9992*index - 0.3271;
+    float Io = exp(bn);
 
     psF32 f2 = bn*pow(z,ALPHA);
     psF32 f1 = Io*exp(-f2);
+
+    psF32 radius = hypot(X, Y);
+    if (radius < 1.0) {
+
+        // ** use bilinear interpolation to the given location from the 4 surrounding pixels centered on the object center
+
+        // first, use Rmajor and index to find the central pixel flux (fraction of total flux)
+        psEllipseShape shape;
+
+        shape.sx  = PAR[PM_PAR_SXX];
+        shape.sy  = PAR[PM_PAR_SYY];
+        shape.sxy = PAR[PM_PAR_SXY];
+
+        // for a non-circular Sersic, the flux of the Rmajor equivalent is scaled by the AspectRatio
+        psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
+
+        // get the central pixel flux from the lookup table
+        float xPix = (axes.major - centralPixelXo) / centralPixeldX;
+        xPix = PS_MIN (PS_MAX(xPix, 0), centralPixelNX - 1);
+        float yPix = (index - centralPixelYo) / centralPixeldY;
+        yPix = PS_MIN (PS_MAX(yPix, 0), centralPixelNY - 1);
+
+        // the integral of a Sersic has an analytical form as follows:
+        float logGamma = lgamma(2.0*index);
+        float bnFactor = pow(bn, 2.0*index);
+        float norm = 2.0 * M_PI * PS_SQR(axes.major) * index * exp(bn) * exp(logGamma) / bnFactor;
+
+        // XXX interpolate to get the value
+        // XXX for the moment, just integerize
+        // XXX I need to multiply by the integrated flux to get the flux in the central pixel
+        float Vcenter = centralPixel[(int)yPix][(int)xPix] * norm;
+        
+        float px1 = 1.0 / PAR[PM_PAR_SXX];
+        float py1 = 1.0 / PAR[PM_PAR_SYY];
+        float z10 = PS_SQR(px1);
+        float z01 = PS_SQR(py1);
+
+        // which pixels do we need for this interpolation?
+        // (I do not keep state information, so I don't know anything about other evaluations of nearby pixels...)
+        if ((X >= 0) && (Y >= 0)) {
+            float z11 = z10 + z01 + PAR[PM_PAR_SXY]; // X * Y positive
+            float V00 = Vcenter;
+            float V10 = Io*exp(-bn*pow(z10,par7));
+            float V01 = Io*exp(-bn*pow(z01,par7));
+            float V11 = Io*exp(-bn*pow(z11,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, X, Y);
+        }
+        if ((X < 0) && (Y >= 0)) {
+            float z11 = z10 + z01 - PAR[PM_PAR_SXY]; // X * Y negative
+            float V00 = Io*exp(-bn*pow(z10,par7));
+            float V10 = Vcenter;
+            float V01 = Io*exp(-bn*pow(z11,par7));
+            float V11 = Io*exp(-bn*pow(z01,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, (1.0 + X), Y);
+        }
+        if ((X >= 0) && (Y < 0)) {
+            float z11 = z10 + z01 - PAR[PM_PAR_SXY]; // X * Y negative
+            float V00 = Io*exp(-bn*pow(z01,par7));
+            float V10 = Io*exp(-bn*pow(z11,par7));
+            float V01 = Vcenter;
+            float V11 = Io*exp(-bn*pow(z10,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, X, (1.0 + Y));
+        }
+        if ((X < 0) && (Y < 0)) {
+            float z11 = z10 + z01 + PAR[PM_PAR_SXY]; // X * Y positive
+            float V00 = Io*exp(-bn*pow(z11,par7));
+            float V10 = Io*exp(-bn*pow(z10,par7));
+            float V01 = Io*exp(-bn*pow(z01,par7));
+            float V11 = Vcenter;
+            f1 = interpolatePixels(V00, V10, V01, V11, (1.0 + X), (1.0 + Y));
+        }
+    }   
+
     psF32 z0 = PAR[PM_PAR_I0]*f1;
     psF32 f0 = PAR[PM_PAR_SKY] + z0;
@@ -120 +199 @@
         psF32 *dPAR = deriv->data.F32;
 
+        dPAR[PM_PAR_SKY]  = +1.0;
+        dPAR[PM_PAR_I0]   = +2.0*f1; // XXX extra damping..
+
         // gradient is infinite for z = 0; saturate at z = 0.01
         psF32 z1 = (z < 0.01) ? z0*bn*ALPHA*pow(0.01,ALPHA - 1.0) : z0*bn*ALPHA*pow(z,ALPHA - 1.0);
-
-        dPAR[PM_PAR_SKY]  = +1.0;
-        dPAR[PM_PAR_I0]   = +2.0*f1;
 
         assert (isfinite(z1));
@@ -223 +302 @@
 
     // set the shape parameters
+    // XXX adjust this?
     if (!pmModelSetShape(&PAR[PM_PAR_SXX], &PAR[PM_PAR_SXY], &PAR[PM_PAR_SYY], source->moments)) {
       return false;
@@ -246 +326 @@
 }
 
+// A DeVaucouleur model is equivalent to a Sersic with index = 4.0
 psF64 PM_MODEL_FLUX (const psVector *params)
 {
-    float z, norm;
     psEllipseShape shape;
 
     psF32 *PAR = params->data.F32;
 
-    shape.sx  = PAR[PM_PAR_SXX] / M_SQRT2;
-    shape.sy  = PAR[PM_PAR_SYY] / M_SQRT2;
+    shape.sx  = PAR[PM_PAR_SXX];
+    shape.sy  = PAR[PM_PAR_SYY];
     shape.sxy = PAR[PM_PAR_SXY];
 
-    // Area is equivalent to 2 pi sigma^2
+    // for a non-circular DeVaucouleur, the flux of the Rmajor equivalent is scaled by the AspectRatio
     psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
-    psF64 Area = 2.0 * M_PI * axes.major * axes.minor;
-
-    // the area needs to be multiplied by the integral of f(z)
-    norm = 0.0;
-
-    # define DZ 0.25
-
-    float f0 = 1.0;
-    float f1, f2;
-    for (z = DZ; z < 150; z += DZ) {
-        f1 = exp(-pow(z,ALPHA));
-        z += DZ;
-        f2 = exp(-pow(z,ALPHA));
-        norm += f0 + 4*f1 + f2;
-        f0 = f2;
-    }
-    norm *= DZ / 3.0;
-
-    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
+    float AspectRatio = axes.minor / axes.major;
+
+    float index = 4.0;
+    float bn = 1.9992*index - 0.3271;
+
+    // the integral of a Sersic has an analytical form as follows:
+    float logGamma = lgamma(2.0*index);
+    float bnFactor = pow(bn, 2.0*index);
+    float norm = 2.0 * M_PI * PS_SQR(axes.major) * index * exp(bn) * exp(logGamma) / bnFactor;
+    
+    psF64 Flux = PAR[PM_PAR_I0] * norm * AspectRatio;
 
     return(Flux);
@@ -297 +369 @@
         return (1.0);
 
-    shape.sx  = PAR[PM_PAR_SXX] / M_SQRT2;
-    shape.sy  = PAR[PM_PAR_SYY] / M_SQRT2;
+    shape.sx  = PAR[PM_PAR_SXX];
+    shape.sy  = PAR[PM_PAR_SYY];
     shape.sxy = PAR[PM_PAR_SXY];
 

branches/meh_branches/ppstack_test/psModules/src/objects/models/pmModel_EXP.c

@@ -81 +81 @@
 static bool limitsApply = true;         // Apply limits?
 
+# include "pmModel_SERSIC.CP.h"
+
 psF32 PM_MODEL_FUNC (psVector *deriv,
                      const psVector *params,
@@ -93 +95 @@
     psF32 z  = PS_SQR(px) + PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y;
 
-    // XXX if the elliptical contour is defined in valid way, this step should not be required.
-    // other models (like PGAUSS) don't use fractional powers, and thus do not have NaN values
-    // for negative values of z
-    // XXX use an assert here to force the elliptical parameters to be correctly determined
-    // if (z < 0) z = 0;
-    assert (z >= 0);
-
-    psF32 f2 = sqrt(z);
-    psF32 f1 = exp(-f2);
+    // If the elliptical contour is defined in a valid way, we should never trigger this
+    // assert.  Other models (like PGAUSS) don't use fractional powers, and thus do not have
+    // NaN values for negative values of z
+    psAssert (z >= 0, "do not allow negative z values in model");
+
+    float index = 1.0;
+    float par7 = 0.5;
+    float bn = 1.9992*index - 0.3271;
+    float Io = exp(bn);
+
+    psF32 f2 = bn*sqrt(z);
+    psF32 f1 = Io*exp(-f2);
+
+    psF32 radius = hypot(X, Y);
+    if (radius < 1.0) {
+
+        // ** use bilinear interpolation to the given location from the 4 surrounding pixels centered on the object center
+
+        // first, use Rmajor and index to find the central pixel flux (fraction of total flux)
+        psEllipseShape shape;
+
+        shape.sx  = PAR[PM_PAR_SXX];
+        shape.sy  = PAR[PM_PAR_SYY];
+        shape.sxy = PAR[PM_PAR_SXY];
+
+        // for a non-circular Sersic, the flux of the Rmajor equivalent is scaled by the AspectRatio
+        psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
+
+        // get the central pixel flux from the lookup table
+        float xPix = (axes.major - centralPixelXo) / centralPixeldX;
+        xPix = PS_MIN (PS_MAX(xPix, 0), centralPixelNX - 1);
+        float yPix = (index - centralPixelYo) / centralPixeldY;
+        yPix = PS_MIN (PS_MAX(yPix, 0), centralPixelNY - 1);
+
+        // the integral of a Sersic has an analytical form as follows:
+        float logGamma = lgamma(2.0*index);
+        float bnFactor = pow(bn, 2.0*index);
+        float norm = 2.0 * M_PI * PS_SQR(axes.major) * index * exp(bn) * exp(logGamma) / bnFactor;
+
+        // XXX interpolate to get the value
+        // XXX for the moment, just integerize
+        // XXX I need to multiply by the integrated flux to get the flux in the central pixel
+        float Vcenter = centralPixel[(int)yPix][(int)xPix] * norm;
+        
+        float px1 = 1.0 / PAR[PM_PAR_SXX];
+        float py1 = 1.0 / PAR[PM_PAR_SYY];
+        float z10 = PS_SQR(px1);
+        float z01 = PS_SQR(py1);
+
+        // which pixels do we need for this interpolation?
+        // (I do not keep state information, so I don't know anything about other evaluations of nearby pixels...)
+        if ((X >= 0) && (Y >= 0)) {
+            float z11 = z10 + z01 + PAR[PM_PAR_SXY]; // X * Y positive
+            float V00 = Vcenter;
+            float V10 = Io*exp(-bn*pow(z10,par7));
+            float V01 = Io*exp(-bn*pow(z01,par7));
+            float V11 = Io*exp(-bn*pow(z11,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, X, Y);
+        }
+        if ((X < 0) && (Y >= 0)) {
+            float z11 = z10 + z01 - PAR[PM_PAR_SXY]; // X * Y negative
+            float V00 = Io*exp(-bn*pow(z10,par7));
+            float V10 = Vcenter;
+            float V01 = Io*exp(-bn*pow(z11,par7));
+            float V11 = Io*exp(-bn*pow(z01,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, (1.0 + X), Y);
+        }
+        if ((X >= 0) && (Y < 0)) {
+            float z11 = z10 + z01 - PAR[PM_PAR_SXY]; // X * Y negative
+            float V00 = Io*exp(-bn*pow(z01,par7));
+            float V10 = Io*exp(-bn*pow(z11,par7));
+            float V01 = Vcenter;
+            float V11 = Io*exp(-bn*pow(z10,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, X, (1.0 + Y));
+        }
+        if ((X < 0) && (Y < 0)) {
+            float z11 = z10 + z01 + PAR[PM_PAR_SXY]; // X * Y positive
+            float V00 = Io*exp(-bn*pow(z11,par7));
+            float V10 = Io*exp(-bn*pow(z10,par7));
+            float V01 = Io*exp(-bn*pow(z01,par7));
+            float V11 = Vcenter;
+            f1 = interpolatePixels(V00, V10, V01, V11, (1.0 + X), (1.0 + Y));
+        }
+    }   
+
     psF32 z0 = PAR[PM_PAR_I0]*f1;
     psF32 f0 = PAR[PM_PAR_SKY] + z0;
@@ -118 +196 @@
         // gradient is infinite for z = 0; saturate at z = 0.01
         // z1 is -df/dz (the negative sign is canceled by most of dz/dPAR[i]
-        psF32 z1 = (z < 0.01) ? 0.5*z0/sqrt(0.01) : 0.5*z0/sqrt(z);
+        psF32 z1 = (z < 0.01) ? 0.5*bn*z0/sqrt(0.01) : 0.5*bn*z0/sqrt(z);
 
         // XXX dampen SXX and SYY as in GAUSS?
@@ -216 +294 @@
 
     // set the shape parameters
+    // XXX adjust this?
     if (!pmModelSetShape(&PAR[PM_PAR_SXX], &PAR[PM_PAR_SXY], &PAR[PM_PAR_SYY], source->moments)) {
       return false;
@@ -233 +312 @@
 }
 
+// An exponential model is equivalent to a Sersic with index = 1.0
 psF64 PM_MODEL_FLUX (const psVector *params)
 {
-    float z, norm;
     psEllipseShape shape;
 
     psF32 *PAR = params->data.F32;
 
-    shape.sx  = PAR[PM_PAR_SXX] / M_SQRT2;
-    shape.sy  = PAR[PM_PAR_SYY] / M_SQRT2;
+    shape.sx  = PAR[PM_PAR_SXX];
+    shape.sy  = PAR[PM_PAR_SYY];
     shape.sxy = PAR[PM_PAR_SXY];
 
-    // Area is equivalent to 2 pi sigma^2
+    // for a non-circular Exponential, the flux of the Rmajor equivalent is scaled by the AspectRatio
     psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
-    psF64 Area = 2.0 * M_PI * axes.major * axes.minor;
-
-    // the area needs to be multiplied by the integral of f(z) = exp(-sqrt(z)) [0 to infinity]
-    norm = 0.0;
-
-    # define DZ 0.25
-
-    float f0 = 1.0;
-    float f1, f2;
-    for (z = DZ; z < 150; z += DZ) {
-        f1 = exp(-sqrt(z));
-        z += DZ;
-        f2 = exp(-sqrt(z));
-        norm += f0 + 4*f1 + f2;
-        f0 = f2;
-    }
-    norm *= DZ / 3.0;
-
-    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
+    float AspectRatio = axes.minor / axes.major;
+
+    float index = 1.0;
+    float bn = 1.9992*index - 0.3271;
+
+    // the integral of a Sersic has an analytical form as follows:
+    float logGamma = lgamma(2.0*index);
+    float bnFactor = pow(bn, 2.0*index);
+    float norm = 2.0 * M_PI * PS_SQR(axes.major) * index * exp(bn) * exp(logGamma) / bnFactor;
+    
+    psF64 Flux = PAR[PM_PAR_I0] * norm * AspectRatio;
 
     return(Flux);
@@ -284 +355 @@
         return (1.0);
 
-    shape.sx  = PAR[PM_PAR_SXX] / M_SQRT2;
-    shape.sy  = PAR[PM_PAR_SYY] / M_SQRT2;
+    shape.sx  = PAR[PM_PAR_SXX];
+    shape.sy  = PAR[PM_PAR_SYY];
     shape.sxy = PAR[PM_PAR_SXY];
 

branches/meh_branches/ppstack_test/psModules/src/objects/models/pmModel_PGAUSS.c

@@ -217 +217 @@
 }
 
-psF64 PM_MODEL_FLUX(const psVector *params)
-{
-    float norm, z;
+// integrate the model to get the full flux
+psF64 PM_MODEL_FLUX (const psVector *params)
+{
+    float z, norm;
     psEllipseShape shape;
 
@@ -228 +229 @@
     shape.sxy = PAR[PM_PAR_SXY];
 
-    // Area is equivalent to 2 pi sigma^2
     psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
-    psF64 Area = 2.0 * M_PI * axes.major * axes.minor;
-
-    // the area needs to be multiplied by the integral of f(z)
+    float AspectRatio = axes.minor / axes.major;
+
+    // flux = 2 \pi \int f(r) r dr
     norm = 0.0;
 
-    # define DZ 0.25
-
-    float f0 = 1.0;
+    # define DR 0.25
+
+    // f = f(r) * r
+    float f0 = 0.0;
     float f1, f2;
-    for (z = DZ; z < 150; z += DZ) {
-        f1 = 1.0 / (1 + z + z*z/2.0 + z*z*z/6.0);
-        z += DZ;
-        f2 = 1.0 / (1 + z + z*z/2.0 + z*z*z/6.0);
+    for (float r = DR; r < 150; r += DR) {
+        z = 0.5 * PS_SQR(r / axes.major);
+        f1 = r / (1 + z + z*z/2.0 + z*z*z/6.0);
+        r += DR;
+        z = 0.5 * PS_SQR(r / axes.major);
+        f2 = r / (1 + z + z*z/2.0 + z*z*z/6.0);
         norm += f0 + 4*f1 + f2;
         f0 = f2;
     }
-    norm *= DZ / 3.0;
-
-    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
+    norm *= DR / 3.0;
+
+    psF64 Flux = PAR[PM_PAR_I0] * norm * 2.0 * M_PI * AspectRatio;
 
     return(Flux);

branches/meh_branches/ppstack_test/psModules/src/objects/models/pmModel_PS1_V1.c

@@ -14 +14 @@
    * PM_PAR_XPOS 2  - X center of object
    * PM_PAR_YPOS 3  - Y center of object
-   * PM_PAR_SXX 4   - X^2 term of elliptical contour (sqrt(2) / SigmaX)
-   * PM_PAR_SYY 5   - Y^2 term of elliptical contour (sqrt(2) / SigmaY)
+   * PM_PAR_SXX 4   - X^2 term of elliptical contour (SigmaX / sqrt(2))
+   * PM_PAR_SYY 5   - Y^2 term of elliptical contour (SigmaY / sqrt(2))
    * PM_PAR_SXY 6   - X*Y term of elliptical contour
    * PM_PAR_7   7   - amplitude of the linear component (k)
@@ -239 +239 @@
 }
 
+// integrate the model to get the full flux
 psF64 PM_MODEL_FLUX (const psVector *params)
 {
@@ -250 +251 @@
     shape.sxy = PAR[PM_PAR_SXY];
 
-    // Area is equivalent to 2 pi sigma^2
     psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
-    psF64 Area = 2.0 * M_PI * axes.major * axes.minor;
-
-    // the area needs to be multiplied by the integral of f(z)
+    float AspectRatio = axes.minor / axes.major;
+
+    // flux = 2 \pi \int f(r) r dr
     norm = 0.0;
 
-    # define DZ 0.25
-
-    float f0 = 1.0;
+    # define DR 0.25
+
+    // f = f(r) * r
+    float f0 = 0.0;
     float f1, f2;
-    for (z = DZ; z < 150; z += DZ) {
-        f1 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
-        z += DZ;
-        f2 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
+    for (float r = DR; r < 150; r += DR) {
+        z = 0.5 * PS_SQR(r / axes.major);
+        f1 = r / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
+        r += DR;
+        z = 0.5 * PS_SQR(r / axes.major);
+        f2 = r / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
         norm += f0 + 4*f1 + f2;
         f0 = f2;
     }
-    norm *= DZ / 3.0;
-
-    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
+    norm *= DR / 3.0;
+
+    psF64 Flux = PAR[PM_PAR_I0] * norm * 2.0 * M_PI * AspectRatio;
 
     return(Flux);

branches/meh_branches/ppstack_test/psModules/src/objects/models/pmModel_QGAUSS.c

@@ -240 +240 @@
 }
 
+// integrate the model to get the full flux
 psF64 PM_MODEL_FLUX (const psVector *params)
 {
@@ -251 +252 @@
     shape.sxy = PAR[PM_PAR_SXY];
 
-    // Area is equivalent to 2 pi sigma^2
     psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
-    psF64 Area = 2.0 * M_PI * axes.major * axes.minor;
-
-    // the area needs to be multiplied by the integral of f(z)
+    float AspectRatio = axes.minor / axes.major;
+
+    // flux = 2 \pi \int f(r) r dr
     norm = 0.0;
 
-    # define DZ 0.25
-
-    float f0 = 1.0;
+    # define DR 0.25
+
+    // f = f(r) * r
+    float f0 = 0.0;
     float f1, f2;
-    for (z = DZ; z < 150; z += DZ) {
-        f1 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
-        z += DZ;
-        f2 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
+    for (float r = DR; r < 150; r += DR) {
+        z = 0.5 * PS_SQR(r / axes.major);
+        f1 = r / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
+        r += DR;
+        z = 0.5 * PS_SQR(r / axes.major);
+        f2 = r / (1 + PAR[PM_PAR_7]*z + pow(z, ALPHA));
         norm += f0 + 4*f1 + f2;
         f0 = f2;
     }
-    norm *= DZ / 3.0;
-
-    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
+    norm *= DR / 3.0;
+
+    psF64 Flux = PAR[PM_PAR_I0] * norm * 2.0 * M_PI * AspectRatio;
 
     return(Flux);

branches/meh_branches/ppstack_test/psModules/src/objects/models/pmModel_RGAUSS.c

@@ -229 +229 @@
 }
 
+// integrate the model to get the full flux
 psF64 PM_MODEL_FLUX (const psVector *params)
 {
-    float norm, z;
+    float z, norm;
     psEllipseShape shape;
 
@@ -240 +241 @@
     shape.sxy = PAR[PM_PAR_SXY];
 
-    // Area is equivalent to 2 pi sigma^2
     psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
-    psF64 Area = 2.0 * M_PI * axes.major * axes.minor;
-
-    // the area needs to be multiplied by the integral of f(z)
+    float AspectRatio = axes.minor / axes.major;
+
+    // flux = 2 \pi \int f(r) r dr
     norm = 0.0;
 
-    # define DZ 0.25
-
-    float f0 = 1.0;
+    # define DR 0.25
+
+    // f = f(r) * r
+    float f0 = 0.0;
     float f1, f2;
-    for (z = DZ; z < 150; z += DZ) {
-        f1 = 1.0 / (1 + z + pow(z, PAR[PM_PAR_7]));
-        z += DZ;
-        f2 = 1.0 / (1 + z + pow(z, PAR[PM_PAR_7]));
+    for (float r = DR; r < 150; r += DR) {
+        z = 0.5 * PS_SQR(r / axes.major);
+        f1 = r / (1 + z + pow(z, PAR[PM_PAR_7]));
+        r += DR;
+        z = 0.5 * PS_SQR(r / axes.major);
+        f2 = r / (1 + z + pow(z, PAR[PM_PAR_7]));
         norm += f0 + 4*f1 + f2;
         f0 = f2;
     }
-    norm *= DZ / 3.0;
-
-    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
+    norm *= DR / 3.0;
+
+    psF64 Flux = PAR[PM_PAR_I0] * norm * 2.0 * M_PI * AspectRatio;
 
     return(Flux);

branches/meh_branches/ppstack_test/psModules/src/objects/models/pmModel_SERSIC.c

@@ -13 +13 @@
    * PM_PAR_XPOS 2  - X center of object
    * PM_PAR_YPOS 3  - Y center of object
-   * PM_PAR_SXX 4   - X^2 term of elliptical contour (sqrt(2) / SigmaX)
-   * PM_PAR_SYY 5   - Y^2 term of elliptical contour (sqrt(2) / SigmaY)
+   * PM_PAR_SXX 4   - X^2 term of elliptical contour (SigmaX / sqrt(2))
+   * PM_PAR_SYY 5   - Y^2 term of elliptical contour (SigmaY / sqrt(2))
    * PM_PAR_SXY 6   - X*Y term of elliptical contour
    * PM_PAR_7   7   - normalized sersic parameter
+
+   * note that a Sersic model is usually defined in terms of R_e, the half-light radius.  This
+     construction does not include a factor of 2 in the X^2 term, etc, like for a Gaussian.
+     Conversion from SXX, SYY, SXY to R_major, R_minor, theta can be done by using setting:
+     shape.sx = SXX / sqrt(2), shape.sy = SYY / sqrt(2), shape.sxy = SXY, then calling
+     psEllipseShapeToAxes, and multiplying the values of axes.major, axes.minor by sqrt(2)
 
    note that a standard sersic model uses exp(-K*(z^(1/2n) - 1).  the additional elements (K,
@@ -85 +91 @@
 static bool limitsApply = true;         // Apply limits?
 
+# include "pmModel_SERSIC.CP.h"
+
 psF32 PM_MODEL_FUNC (psVector *deriv,
                      const psVector *params,
@@ -97 +105 @@
     psF32 z  = PS_SQR(px) + PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y;
 
-    // XXX if the elliptical contour is defined in valid way, this step should not be required.
-    // other models (like PGAUSS) don't use fractional powers, and thus do not have NaN values
-    // for negative values of z
-    // XXX use an assert here to force the elliptical parameters to be correctly determined
-    // if (z < 0) z = 0;
-    assert (z >= 0);
+    // If the elliptical contour is defined in a valid way, we should never trigger this
+    // assert.  Other models (like PGAUSS) don't use fractional powers, and thus do not have
+    // NaN values for negative values of z
+    psAssert (z >= 0, "do not allow negative z values in model");
 
     float index = 0.5 / PAR[PM_PAR_7];
+    float par7 = PAR[PM_PAR_7];
     float bn = 1.9992*index - 0.3271;
     float Io = exp(bn);
 
-    psF32 f2 = bn*pow(z,PAR[PM_PAR_7]);
+    psF32 f2 = bn*pow(z,par7);
     psF32 f1 = Io*exp(-f2);
+
+    psF32 radius = hypot(X, Y);
+    if (radius < 1.0) {
+
+        // ** use bilinear interpolation to the given location from the 4 surrounding pixels centered on the object center
+
+        // first, use Rmajor and index to find the central pixel flux (fraction of total flux)
+        psEllipseShape shape;
+
+        shape.sx  = PAR[PM_PAR_SXX];
+        shape.sy  = PAR[PM_PAR_SYY];
+        shape.sxy = PAR[PM_PAR_SXY];
+
+        // for a non-circular Sersic, the flux of the Rmajor equivalent is scaled by the AspectRatio
+        psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
+
+        // get the central pixel flux from the lookup table
+        float xPix = (axes.major - centralPixelXo) / centralPixeldX;
+        xPix = PS_MIN (PS_MAX(xPix, 0), centralPixelNX - 1);
+        float yPix = (index - centralPixelYo) / centralPixeldY;
+        yPix = PS_MIN (PS_MAX(yPix, 0), centralPixelNY - 1);
+
+        // the integral of a Sersic has an analytical form as follows:
+        float logGamma = lgamma(2.0*index);
+        float bnFactor = pow(bn, 2.0*index);
+        float norm = 2.0 * M_PI * PS_SQR(axes.major) * index * exp(bn) * exp(logGamma) / bnFactor;
+
+        // XXX interpolate to get the value
+        // XXX for the moment, just integerize
+        // XXX I need to multiply by the integrated flux to get the flux in the central pixel
+        float Vcenter = centralPixel[(int)yPix][(int)xPix] * norm;
+        
+        float px1 = 1.0 / PAR[PM_PAR_SXX];
+        float py1 = 1.0 / PAR[PM_PAR_SYY];
+        float z10 = PS_SQR(px1);
+        float z01 = PS_SQR(py1);
+
+        // which pixels do we need for this interpolation?
+        // (I do not keep state information, so I don't know anything about other evaluations of nearby pixels...)
+        if ((X >= 0) && (Y >= 0)) {
+            float z11 = z10 + z01 + PAR[PM_PAR_SXY]; // X * Y positive
+            float V00 = Vcenter;
+            float V10 = Io*exp(-bn*pow(z10,par7));
+            float V01 = Io*exp(-bn*pow(z01,par7));
+            float V11 = Io*exp(-bn*pow(z11,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, X, Y);
+        }
+        if ((X < 0) && (Y >= 0)) {
+            float z11 = z10 + z01 - PAR[PM_PAR_SXY]; // X * Y negative
+            float V00 = Io*exp(-bn*pow(z10,par7));
+            float V10 = Vcenter;
+            float V01 = Io*exp(-bn*pow(z11,par7));
+            float V11 = Io*exp(-bn*pow(z01,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, (1.0 + X), Y);
+        }
+        if ((X >= 0) && (Y < 0)) {
+            float z11 = z10 + z01 - PAR[PM_PAR_SXY]; // X * Y negative
+            float V00 = Io*exp(-bn*pow(z01,par7));
+            float V10 = Io*exp(-bn*pow(z11,par7));
+            float V01 = Vcenter;
+            float V11 = Io*exp(-bn*pow(z10,par7));
+            f1 = interpolatePixels(V00, V10, V01, V11, X, (1.0 + Y));
+        }
+        if ((X < 0) && (Y < 0)) {
+            float z11 = z10 + z01 + PAR[PM_PAR_SXY]; // X * Y positive
+            float V00 = Io*exp(-bn*pow(z11,par7));
+            float V10 = Io*exp(-bn*pow(z10,par7));
+            float V01 = Io*exp(-bn*pow(z01,par7));
+            float V11 = Vcenter;
+            f1 = interpolatePixels(V00, V10, V01, V11, (1.0 + X), (1.0 + Y));
+        }
+    }   
+
     psF32 z0 = PAR[PM_PAR_I0]*f1;
     psF32 f0 = PAR[PM_PAR_SKY] + z0;
@@ -121 +201 @@
         psF32 *dPAR = deriv->data.F32;
 
-        // gradient is infinite for z = 0; saturate at z = 0.01
-        psF32 z1 = (z < 0.01) ? z0*bn*PAR[PM_PAR_7]*pow(0.01,PAR[PM_PAR_7] - 1.0) : z0*bn*PAR[PM_PAR_7]*pow(z,PAR[PM_PAR_7] - 1.0);
-
         dPAR[PM_PAR_SKY]  = +1.0;
         dPAR[PM_PAR_I0]   = +f1;
-        dPAR[PM_PAR_7]    = (z < 0.01) ? -z0*pow(0.01,PAR[PM_PAR_7])*log(0.01) : -z0*f2*log(z);
+
+        // gradient is infinite for z = 0; saturate at z = 0.01
+        psF32 z1 = (z < 0.01) ? z0*bn*par7*pow(0.01,par7 - 1.0) : z0*bn*par7*pow(z,par7 - 1.0);
+
+        dPAR[PM_PAR_7]    = (z < 0.01) ? -z0*pow(0.01,par7)*log(0.01) : -z0*f2*log(z);
         dPAR[PM_PAR_7]   *= 3.0;
 
@@ -269 +350 @@
     float Io = exp(0.5*bn);
 
-    // XXX do we need this factor of sqrt(2)?
-    // float Sxx = PS_MAX(0.5, M_SQRT2*shape.sx);
-    // float Syy = PS_MAX(0.5, M_SQRT2*shape.sy);
-
     float Sxx = PS_MAX(0.5, shape.sx);
     float Syy = PS_MAX(0.5, shape.sy);
@@ -294 +371 @@
 }
 
+// A sersic model has an integral flux which can be analytically represented
 psF64 PM_MODEL_FLUX (const psVector *params)
 {
-    float z, norm;
     psEllipseShape shape;
 
     psF32 *PAR = params->data.F32;
 
-    shape.sx  = PAR[PM_PAR_SXX] / M_SQRT2;
-    shape.sy  = PAR[PM_PAR_SYY] / M_SQRT2;
+    shape.sx  = PAR[PM_PAR_SXX];
+    shape.sy  = PAR[PM_PAR_SYY];
     shape.sxy = PAR[PM_PAR_SXY];
 
-    // Area is equivalent to 2 pi sigma^2
+    // for a non-circular Sersic, the flux of the Rmajor equivalent is scaled by the AspectRatio
     psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0);
-    psF64 Area = 2.0 * M_PI * axes.major * axes.minor;
-
-    // the area needs to be multiplied by the integral of f(z)
-    norm = 0.0;
-
-    # define DZ 0.25
-
-    float f0 = 1.0;
-    float f1, f2;
-    for (z = DZ; z < 150; z += DZ) {
-        // f1 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, 2.25));
-        f1 = exp(-pow(z,PAR[PM_PAR_7]));
-        z += DZ;
-        f2 = exp(-pow(z,PAR[PM_PAR_7]));
-        norm += f0 + 4*f1 + f2;
-        f0 = f2;
-    }
-    norm *= DZ / 3.0;
-
-    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
+    float AspectRatio = axes.minor / axes.major;
+
+    float index = 0.5 / PAR[PM_PAR_7];
+    float bn = 1.9992*index - 0.3271;
+
+    // the integral of a Sersic has an analytical form as follows:
+    float logGamma = lgamma(2.0*index);
+    float bnFactor = pow(bn, 2.0*index);
+    float norm = 2.0 * M_PI * PS_SQR(axes.major) * index * exp(bn) * exp(logGamma) / bnFactor;
+    
+    psF64 Flux = PAR[PM_PAR_I0] * norm * AspectRatio;
 
     return(Flux);
@@ -346 +414 @@
         return (1.0);
 
-    shape.sx  = PAR[PM_PAR_SXX] / M_SQRT2;
-    shape.sy  = PAR[PM_PAR_SYY] / M_SQRT2;
+    shape.sx  = PAR[PM_PAR_SXX];
+    shape.sy  = PAR[PM_PAR_SYY];
     shape.sxy = PAR[PM_PAR_SXY];
 

branches/meh_branches/ppstack_test/psModules/src/objects/pmFootprintCullPeaks.c

@@ -118 +118 @@
             threshbounds->data.F32[i] = 0.25*beta2*PS_SQR(i) + min_threshold;       
         }
-        psAssert(threshbounds->data.F32[threshbounds->n-1] > maxFlux, "upper limit does not include max flux");
-
+        if (threshbounds->data.F32[threshbounds->n-1] > maxFlux) {
+            psWarning ("upper limit: %f does not include max flux: %f",
+                    threshbounds->data.F32[threshbounds->n-1], maxFlux);
+        }
         psHistogram *threshist = psHistogramAllocGeneric(threshbounds);
 
@@ -181 +183 @@
             if (!myFP->n) {
                 psWarning ("empty footprint?");
+                psFree (myFP);
                 continue;
             }

branches/meh_branches/ppstack_test/psModules/src/objects/pmModelUtils.c

@@ -122 +122 @@
     if (!isfinite(axes.theta)) return false;
 
+    // Mxx, Mxy, Myy define the elliptical shape, but Mrf defines the width 
+    float scale = (isfinite(moments->Mrf) && (moments->Mrf > 0.0)) ? moments->Mrf / axes.major : 1.0;
+    axes.major *= scale;
+    axes.minor *= scale;
+
     psEllipseShape shape = psEllipseAxesToShape (axes);
 

branches/meh_branches/ppstack_test/psModules/src/objects/pmMoments.c

@@ -32 +32 @@
     tmp->Mrf = 0.0;
     tmp->Mrh = 0.0;
+
+    tmp->KronCore = 0.0;
+    tmp->KronCoreErr = 0.0;
+
     tmp->KronFlux = 0.0;
     tmp->KronFluxErr = 0.0;
@@ -37 +41 @@
     tmp->KronFinner = 0.0;
     tmp->KronFouter = 0.0;
+
+    tmp->KronFluxPSF = 0.0;
+    tmp->KronFluxPSFErr = 0.0;
+    tmp->KronRadiusPSF = 0.0;
 
     tmp->Mx = 0.0;

branches/meh_branches/ppstack_test/psModules/src/objects/pmMoments.h

@@ -51 +51 @@
     int nPixels;  ///< Number of pixels used.
 
+    float KronFluxPSF; ///< Kron Flux using PSF-optimized window
+    float KronFluxPSFErr; ///< Kron Flux Error using PSF-optimized window
+    float KronRadiusPSF; ///< Kron Radius using PSF-optimized window (Flux in 2.5 Radius)
+
     float KronCore;    ///< flux in r < 1.0*Mrf
     float KronCoreErr;    ///< error on flux in r < 1.0*Mrf

branches/meh_branches/ppstack_test/psModules/src/objects/pmPCM_MinimizeChisq.c

@@ -45 +45 @@
 # define USE_FFT 1
 # define PRE_CONVOLVE 1
+# define TESTCOPY 0
 
 bool pmPCM_MinimizeChisq (
@@ -93 +94 @@
         psFree (pcm->psfFFT);
     }
-    pcm->psfFFT = psImageConvolveKernelInit(pcm->modelFlux, pcm->psf);
+# if (!TESTCOPY)
+    if (!pcm->use1Dgauss) {
+        pcm->psfFFT = psImageConvolveKernelInit(pcm->modelFlux, pcm->psf);
+    }
+# endif
 # endif    
 
@@ -285 +290 @@
 
             // Convert i/j to image space:
-            coord->data.F32[0] = (psF32) (j + source->pixels->col0);
-            coord->data.F32[1] = (psF32) (i + source->pixels->row0);
+            coord->data.F32[0] = (psF32) (j + 0.5 + source->pixels->col0);
+            coord->data.F32[1] = (psF32) (i + 0.5 + source->pixels->row0);
 
             pcm->modelFlux->data.F32[i][j] = pcm->modelConv->modelFunc (deriv, params, coord);
@@ -309 +314 @@
 # if (PRE_CONVOLVE)
     // convolve model image and derivative images with pre-convolved kernel
-    psImageConvolveKernel (pcm->modelConvFlux, pcm->modelFlux, NULL, 0, pcm->psfFFT);
+
+// XXX for a test, just copy, rather than convolve
+# if (TESTCOPY)
+    psImageCopy (pcm->modelConvFlux, pcm->modelFlux, pcm->modelFlux->type.type);
+# else
+    if (pcm->use1Dgauss) {
+        // do not use the threaded, mask-aware version of this code (psImageSmoothMaskPixelsThread):
+        // * the model flux is not masked
+        // * threading takes place above this level
+        pcm->modelConvFlux = psImageCopy (pcm->modelConvFlux, pcm->modelFlux, pcm->modelFlux->type.type);
+        psImageSmooth_PreAlloc_F32 (pcm->modelConvFlux, pcm->smdata);
+        // psImageSmooth (pcm->modelConvFlux, pcm->sigma, pcm->nsigma);
+    } else {
+        psImageConvolveKernel (pcm->modelConvFlux, pcm->modelFlux, NULL, 0, pcm->psfFFT);
+    }
+# endif
+
     for (int n = 0; n < pcm->dmodelsFlux->n; n++) {
         if (pcm->dmodelsFlux->data[n] == NULL) continue;
@@ -315 +336 @@
         psImage *dmodel = pcm->dmodelsFlux->data[n];
         psImage *dmodelConv = pcm->dmodelsConvFlux->data[n];
-        psImageConvolveKernel (dmodelConv, dmodel, NULL, 0, pcm->psfFFT);
+# if (TESTCOPY)
+        psImageCopy (dmodelConv, dmodel, dmodel->type.type);
+# else
+        if (pcm->use1Dgauss) {
+            // do not use the threaded, mask-aware version of this code (psImageSmoothMaskPixelsThread):
+            // * the model flux is not masked
+            // * threading takes place above this level
+            dmodelConv = psImageCopy (dmodelConv, dmodel, dmodel->type.type);
+            psImageSmooth_PreAlloc_F32 (dmodelConv, pcm->smdata);
+            // psImageSmooth (dmodelConv, pcm->sigma, pcm->nsigma);
+        } else {
+            psImageConvolveKernel (dmodelConv, dmodel, NULL, 0, pcm->psfFFT);
+        }
+# endif
     }
 # else
@@ -325 +359 @@
         psImage *dmodel = pcm->dmodelsFlux->data[n];
         psImage *dmodelConv = pcm->dmodelsConvFlux->data[n];
-        psImageConvolveFFT (dmodelConv, dmodel, NULL, 0, pcm->psf);
+
+        if (pcm->use1Dgauss) {
+            // do not use the threaded, mask-aware version of this code (psImageSmoothMaskPixelsThread):
+            // * the model flux is not masked
+            // * threading takes place above this level
+            dmodelConv = psImageCopy (dmodelConv, dmodel, dmodel->type.type);
+            psImageSmooth_PreAlloc_F32 (dmodelConv, pcm->smdata);
+            // psImageSmooth (dmodelConv, pcm->sigma, pcm->nsigma);
+        } else {
+            psImageConvolveFFT (dmodelConv, dmodel, NULL, 0, pcm->psf);
+        }
     }
 # endif // PRE-CONVOLVE

branches/meh_branches/ppstack_test/psModules/src/objects/pmPCMdata.c

@@ -41 +41 @@
 #include "pmPCMdata.h"
 
+# define USE_DELTA_PSF 0
+# define USE_1D_GAUSS 1
+
 static void pmPCMdataFree (pmPCMdata *pcm) {
 
@@ -54 +57 @@
     psFree (pcm->psfFFT);
     psFree (pcm->constraint);
+    psFree (pcm->smdata); // pre-allocated data for psImageSmooth_PreAlloc
     return;
 }
@@ -88 +92 @@
     pcm->constraint = NULL;
     pcm->nDOF = 0;
+
+    // full convolution with the PSF is expensive.  if we have to save time, we can do a 1D
+    // convolution with a Gaussian approximation to the kernel
+    pcm->use1Dgauss = false;
+    pcm->nsigma = 3.0; 
+    pcm->sigma = 1.0; // this should be set to something sensible when the psf is known
 
     return pcm;
@@ -257 +267 @@
     pcm->nDOF = nPix - nParams;
 
+# if (USE_1D_GAUSS)
+    pmModel *modelPSF = source->modelPSF;
+    psAssert (modelPSF, "psf model must be defined");
+    
+    psEllipseShape shape;
+    psEllipseAxes axes;
+
+    shape.sx  = modelPSF->params->data.F32[PM_PAR_SXX];
+    shape.sy  = modelPSF->params->data.F32[PM_PAR_SYY];
+    shape.sxy = modelPSF->params->data.F32[PM_PAR_SXY];
+    axes = psEllipseShapeToAxes (shape, 20.0);
+    
+    float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*modelPSF->params->data.F32[PM_PAR_I0]);
+    float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
+
+    pcm->use1Dgauss = true;
+    pcm->sigma = 0.5 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
+    pcm->nsigma = 2.0;
+
+    pcm->smdata = psImageSmooth_PreAlloc_DataAlloc (source->pixels, pcm->sigma, pcm->nsigma);
+# else
+    pcm->smdata = NULL;
+# endif
+
     return pcm;
 }
@@ -364 +398 @@
             pcm->dmodelsConvFlux->data[n] = psImageCopy (pcm->dmodelsConvFlux->data[n], source->pixels, PS_TYPE_F32);
         }
+        psFree(pcm->smdata);
+        pcm->smdata = psImageSmooth_PreAlloc_DataAlloc (source->pixels, pcm->sigma, pcm->nsigma);
     }
 
     return true;
 }
+
+// construct a realization of the source model
+bool pmPCMCacheModel (pmSource *source, psImageMaskType maskVal, int psfSize) {
+
+    PS_ASSERT_PTR_NON_NULL(source, false);
+
+    // select appropriate model
+    pmModel *model = pmSourceGetModel (NULL, source);
+    if (model == NULL) return false;  // model must be defined
+
+    // if we already have a cached image, re-use that memory
+    source->modelFlux = psImageCopy (source->modelFlux, source->pixels, PS_TYPE_F32);
+    psImageInit (source->modelFlux, 0.0);
+
+    // modelFlux always has unity normalization (I0 = 1.0)
+    pmModelAdd (source->modelFlux, source->maskObj, model, PM_MODEL_OP_FULL | PM_MODEL_OP_NORM, maskVal);
+
+    // convolve the model image with the PSF
+    if (USE_1D_GAUSS) {
+        // do not use the threaded, mask-aware version of this code (psImageSmoothMaskPixelsThread):
+        // * the model flux is not masked
+        // * threading takes place above this level
+        
+        // define the Gauss parameters from the psf
+        pmModel *modelPSF = source->modelPSF;
+        psAssert (modelPSF, "psf model must be defined");
+    
+        psEllipseShape shape;
+        psEllipseAxes axes;
+
+        shape.sx  = modelPSF->params->data.F32[PM_PAR_SXX];
+        shape.sy  = modelPSF->params->data.F32[PM_PAR_SYY];
+        shape.sxy = modelPSF->params->data.F32[PM_PAR_SXY];
+        axes = psEllipseShapeToAxes (shape, 20.0);
+    
+        float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*modelPSF->params->data.F32[PM_PAR_I0]);
+        float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
+
+        float sigma = 0.5 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
+        float nsigma = 2.0;
+
+        psImageSmooth (source->modelFlux, sigma, nsigma);
+    } else {
+        // make sure we save a cached copy of the psf flux
+        pmSourceCachePSF (source, maskVal);
+
+        // convert the cached cached psf model for this source to a psKernel
+        psKernel *psf = pmPCMkernelFromPSF (source, psfSize);
+        if (!psf) {
+            // NOTE: this only happens if the source is too close to an edge
+            model->flags |= PM_MODEL_STATUS_BADARGS;
+            return NULL;
+        }
+
+        // XXX not sure if I can place the output on top of the input
+        psImageConvolveFFT (source->modelFlux, source->modelFlux, NULL, 0, psf);
+    }
+    return true;
+}
+

branches/meh_branches/ppstack_test/psModules/src/objects/pmPCMdata.h

@@ -35 +35 @@
     int nPar;
     int nDOF;
+
+    bool use1Dgauss;
+    float sigma;
+    float nsigma;
+
+    psImageSmooth_PreAlloc_Data *smdata;
 } pmPCMdata;
 
@@ -90 +96 @@
 bool pmSourceFitPCM (pmPCMdata *pcm, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal, int psfSize);
 
+bool pmPCMCacheModel (pmSource *source, psImageMaskType maskVal, int psfSize);
 
 /// @}

branches/meh_branches/ppstack_test/psModules/src/objects/pmPSF.c

@@ -281 +281 @@
 // convert the parameters used in the fitted source model
 // to the parameters used in the 2D PSF model
+// XXX this function may be invalid for SERSIC, DEV, EXP models (SQRT2 not used?)
 bool pmPSF_FitToModel (psF32 *fittedPar, float minMinorAxis)
 {
@@ -307 +308 @@
 // convert the PSF parameters used in the 2D PSF model fit into the
 // parameters used in the source model
+// XXX this function may be invalid for SERSIC, DEV, EXP models (SQRT2 not used?)
 psEllipsePol pmPSF_ModelToFit (psF32 *modelPar)
 {
@@ -329 +331 @@
 // convert the parameters used in the fitted source model to the psEllipseAxes representation
 // (major,minor,theta)
-psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, double maxAR)
+psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, double maxAR, pmModelType type)
 {
     psEllipseShape shape;
@@ -336 +338 @@
     axes.minor = NAN;
     axes.theta = NAN;
-//   XXX: must assert non-NULL input parameter
+    //   XXX: must assert non-NULL input parameter
     PS_ASSERT_PTR_NON_NULL(modelPar, axes);
 
-    shape.sx  = modelPar[PM_PAR_SXX] / M_SQRT2;
-    shape.sy  = modelPar[PM_PAR_SYY] / M_SQRT2;
-    shape.sxy = modelPar[PM_PAR_SXY];
+    bool useReff = true;
+    useReff |= (type == pmModelClassGetType ("PS_MODEL_SERSIC"));
+    useReff |= (type == pmModelClassGetType ("PS_MODEL_DEV"));
+    useReff |= (type == pmModelClassGetType ("PS_MODEL_EXP"));
+
+    if (useReff) {
+        shape.sx  = modelPar[PM_PAR_SXX];
+        shape.sy  = modelPar[PM_PAR_SYY];
+        shape.sxy = modelPar[PM_PAR_SXY];
+    } else {
+        shape.sx  = modelPar[PM_PAR_SXX] / M_SQRT2;
+        shape.sy  = modelPar[PM_PAR_SYY] / M_SQRT2;
+        shape.sxy = modelPar[PM_PAR_SXY];
+    }
 
     if ((shape.sx == 0) || (shape.sy == 0)) {
@@ -357 +370 @@
 // convert the psEllipseAxes representation (major,minor,theta) to the parameters used in the
 // fitted source model
-bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes)
+bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes, pmModelType type)
 {
     PS_ASSERT_PTR_NON_NULL(modelPar, false);
@@ -370 +383 @@
     psEllipseShape shape = psEllipseAxesToShape (axes);
 
-    modelPar[PM_PAR_SXX] = shape.sx * M_SQRT2;
-    modelPar[PM_PAR_SYY] = shape.sy * M_SQRT2;
-    modelPar[PM_PAR_SXY] = shape.sxy;
-
+    bool useReff = true;
+    useReff |= pmModelClassGetType ("PS_MODEL_SERSIC");
+    useReff |= pmModelClassGetType ("PS_MODEL_DEV");
+    useReff |= pmModelClassGetType ("PS_MODEL_EXP");
+
+    if (useReff) {
+        modelPar[PM_PAR_SXX] = shape.sx;
+        modelPar[PM_PAR_SYY] = shape.sy;
+        modelPar[PM_PAR_SXY] = shape.sxy;
+    } else {
+        modelPar[PM_PAR_SXX] = shape.sx * M_SQRT2;
+        modelPar[PM_PAR_SYY] = shape.sy * M_SQRT2;
+        modelPar[PM_PAR_SXY] = shape.sxy;
+    }
     return true;
 }
@@ -438 +461 @@
 # if (0)
     psF32 *params = model->params->data.F32; // Model parameters
-    psEllipseAxes axes = pmPSF_ModelToAxes(params, MAX_AXIS_RATIO); // Ellipse axes
+    psEllipseAxes axes = pmPSF_ModelToAxes(params, MAX_AXIS_RATIO, model->type); // Ellipse axes
 
     // Curiously, the minor axis can be larger than the major axis, so need to check.

branches/meh_branches/ppstack_test/psModules/src/objects/pmPSF.h

@@ -106 +106 @@
 pmPSF *pmPSFBuildSimple (char *typeName, float sxx, float syy, float sxy, ...);
 
-bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes);
+bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes, pmModelType type);
 bool pmPSF_FitToModel (psF32 *fittedPar, float minMinorAxis);
 
 psEllipsePol pmPSF_ModelToFit (psF32 *modelPar);
-psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, double maxAR);
+psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, double maxAR, pmModelType type);
 
 /// Calculate FWHM value from a PSF

branches/meh_branches/ppstack_test/psModules/src/objects/pmPeaks.c

@@ -137 +137 @@
 *****************************************************************************/
 static void peakFree(pmPeak *tmp)
-{} //
+{
+    if (!tmp) return;
+    psFree (tmp->saddlePoints);
+    return;
+}
 
 pmPeak *pmPeakAlloc(psS32 x,
@@ -162 +166 @@
     tmp->type = type;
     tmp->footprint = NULL;
+    tmp->saddlePoints = NULL;
 
     psMemSetDeallocator(tmp, (psFreeFunc) peakFree);
@@ -185 +190 @@
     out->assigned        = in->assigned;
     out->type            = in->type;
+    out->footprint       = in->footprint;
 
     return true;

branches/meh_branches/ppstack_test/psModules/src/objects/pmPeaks.h

@@ -71 +71 @@
     bool assigned;                      ///< is peak assigned to a source?
     pmPeakType type;                    ///< Description of peak.
-    pmFootprint *footprint;             ///< reference to containing footprint
+    pmFootprint *footprint;             ///< reference to containing footprint (just a view, not a memcopy)
+    psArray *saddlePoints;              ///< set of saddle points between this peak and near neighbors
 }
 pmPeak;

branches/meh_branches/ppstack_test/psModules/src/objects/pmSource.c

@@ -58 +58 @@
     psFree(tmp->modelEXT);
     psFree(tmp->modelFits);
+    psFree(tmp->extFitPars);
     psFree(tmp->extpars);
     psFree(tmp->moments);
@@ -119 +120 @@
     source->modelEXT = NULL;
     source->modelFits = NULL;
+    source->extFitPars = NULL;
+
     source->type = PM_SOURCE_TYPE_UNKNOWN;
     source->mode = PM_SOURCE_MODE_DEFAULT;
@@ -136 +139 @@
     source->apFluxErr        = NAN; 
 
+    source->windowRadius     = NAN;
+    source->skyRadius        = NAN;
+    source->skyFlux          = NAN;
+    source->skySlope         = NAN;
+
     source->pixWeightNotBad  = NAN;
     source->pixWeightNotPoor = NAN;
@@ -196 +204 @@
     // NOTE : because of the const id element, we cannot just assign *source = *in
 
+    source->imageID          = in->imageID;
+
     source->type             = in->type;
     source->mode             = in->mode;
     source->mode2            = in->mode2;
     source->tmpFlags         = in->tmpFlags;
+
     source->psfMag           = in->psfMag;
     source->psfMagErr        = in->psfMagErr;
@@ -210 +221 @@
     source->apFlux           = in->apFlux;
     source->apFluxErr        = in->apFluxErr;
+
+    source->windowRadius     = in->windowRadius;
+    source->skyRadius        = in->skyRadius;   
+    source->skyFlux          = in->skyFlux;     
+    source->skySlope         = in->skySlope;    
+
     source->pixWeightNotBad  = in->pixWeightNotBad;
     source->pixWeightNotPoor = in->pixWeightNotPoor;
+
     source->psfChisq         = in->psfChisq;
     source->crNsigma         = in->crNsigma;
@@ -252 +270 @@
     }
     mySource->region   = srcRegion;
+    mySource->windowRadius = Radius;
 
     return true;
@@ -321 +340 @@
         mySource->psfImage = NULL;
     }
+    mySource->windowRadius = Radius;
     return extend;
 }

branches/meh_branches/ppstack_test/psModules/src/objects/pmSource.h

@@ -36 +36 @@
     PM_SOURCE_TMPF_MOMENTS_MEASURED  = 0x0010,
     PM_SOURCE_TMPF_CANDIDATE_PSFSTAR = 0x0020,
+    PM_SOURCE_TMPF_RADIAL_KEEP       = 0x0040,
+    PM_SOURCE_TMPF_RADIAL_SKIP       = 0x0080,
+    PM_SOURCE_TMPF_PETRO_KEEP        = 0x0100,
+    PM_SOURCE_TMPF_PETRO_SKIP        = 0x0200,
 } pmSourceTmpF;
 
@@ -76 +80 @@
     pmModel *modelEXT;                  ///< EXT Model fit used for subtraction (parameters and type)
     psArray *modelFits;                 ///< collection of extended source models (best == modelEXT)
+    psArray *extFitPars;                ///< extra extended fit parameters
     pmSourceType type;                  ///< Best identification of object.
     pmSourceMode mode;                  ///< analysis flags set for object.
@@ -91 +96 @@
     float apFlux;                       ///< apFlux corresponding to psfMag or extMag (depending on type)
     float apFluxErr;                    ///< apFluxErr corresponding to psfMag or extMag (depending on type)
+
+    float windowRadius;                 ///< size of box used for full analysis
+    float skyRadius;                    ///< radius at which profile hits local sky (or goes flat)
+    float skyFlux;                      ///< mean flux per pixel in aperture at which profile hits local sky (or goes flat)
+    float skySlope;                     ///< mean flux slope at which profile hits local sky (or goes flat)
 
     float pixWeightNotBad;              ///< PSF-weighted coverage of unmasked (not BAD) pixels

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceExtendedPars.c

@@ -258 +258 @@
     return ( psMemGetDeallocator(ptr) == (psFreeFunc) pmSourceExtendedFluxFree);
 }
+
+// *** pmSourceExtFitPars describes extra metadata related to an extended fit
+static void pmSourceExtFitParsFree (pmSourceExtFitPars *pars) {
+    return;
+}
+
+pmSourceExtFitPars *pmSourceExtFitParsAlloc (void) {
+
+    pmSourceExtFitPars *pars = (pmSourceExtFitPars *) psAlloc(sizeof(pmSourceExtFitPars));
+    psMemSetDeallocator(pars, (psFreeFunc) pmSourceExtFitParsFree);
+
+    pars->Mxx = NAN;
+    pars->Mxy = NAN;
+    pars->Myy = NAN;
+
+    pars->Mrf    = NAN;
+    pars->Mrh    = NAN;
+
+    pars->apMag  = NAN;
+    pars->krMag  = NAN;
+    pars->psfMag = NAN;
+    pars->peakMag = NAN;
+
+    return pars;
+}

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceExtendedPars.h

@@ -67 +67 @@
 } pmSourceExtendedPars;
 
+// additional measurements related to the model fits
+typedef struct {
+    float Mxx;
+    float Mxy;
+    float Myy;
+    
+    float Mrf;
+    float Mrh;
+
+    float apMag;
+    float krMag;
+    float psfMag;
+    float peakMag;
+} pmSourceExtFitPars;
+
 pmSourceRadialFlux *pmSourceRadialFluxAlloc();
 bool psMemCheckSourceRadialFlux(psPtr ptr);
@@ -92 +107 @@
 bool pmSourceRadialProfileSortPair(psVector *index, psVector *extra);
 
-
+pmSourceExtFitPars *pmSourceExtFitParsAlloc (void);
 
 /// @}

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceFitModel.c

@@ -176 +176 @@
         break;
       case PM_SOURCE_FIT_EXT:
-        // EXT model fits all params (except sky)
-        nParams = params->n - 1;
+        // EXT model fits all shape params and Io (not Xo, Yo, sky)
+        nParams = params->n - 3;
         psVectorInit (constraint->paramMask, 0);
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_XPOS] = 1;
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_YPOS] = 1;
         constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1;
         break;
@@ -193 +195 @@
         break;
       case PM_SOURCE_FIT_NO_INDEX:
-        // PSF model only fits Io, index (PAR7) -- only Io for models with < 8 params
+        // PSF model only fits Io, Sxx, Sxy, Syy
         psVectorInit (constraint->paramMask, 0);
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_XPOS] = 1;
+        constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_YPOS] = 1;
         constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1;
         if (params->n == 7) {
-            nParams = params->n - 1;
+            nParams = params->n - 3;
         } else {
-            nParams = params->n - 2;
+            nParams = params->n - 4;
             constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_7] = 1;
         }

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceFitPCM.c

@@ -48 +48 @@
 // convolved model image.
 
+# define TIMING 0
+
 bool pmSourceFitPCM (pmPCMdata *pcm, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) {
     
+    if (TIMING) { psTimerStart ("pmSourceFitPCM"); }
+
     psVector *params  = pcm->modelConv->params;
     psVector *dparams  = pcm->modelConv->dparams;
@@ -63 +67 @@
 
     psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F32);
+    // NOTE : 4 allocs to here
 
+    float t1, t2, t3, t4, t5;
+    if (TIMING) { t1 = psTimerMark ("pmSourceFitPCM"); }
+
+    // NOTE : 996 allocs in here
     bool fitStatus = pmPCM_MinimizeChisq (myMin, covar, params, source, pcm);
+    if (TIMING) { t2 = psTimerMark ("pmSourceFitPCM"); }
+
     for (int i = 0; i < dparams->n; i++) {
         if ((pcm->constraint->paramMask != NULL) && pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
@@ -76 +87 @@
     }
     psTrace ("psphot", 4, "niter: %d, chisq: %f", myMin->iter, myMin->value);
+    if (TIMING) { t3 = psTimerMark ("pmSourceFitPCM"); }
 
     // renormalize output model image (generated by fitting process)
@@ -97 +109 @@
         pmSourceChisqUnsubtracted (source, pcm->modelConv, maskVal);
     }
+    if (TIMING) { t4 = psTimerMark ("pmSourceFitPCM"); }
 
     // set the model success or failure status
@@ -114 +127 @@
 
     source->mode |= PM_SOURCE_MODE_FITTED; // XXX is this needed?
+    if (TIMING) { t5 = psTimerMark ("pmSourceFitPCM"); }
+
+     if (TIMING) {
+        fprintf (stderr, "nIter: %2d, npix: %5d, t1: %6.4f, t2: %6.4f, t3: %6.4f, t4: %6.4f, t5: %6.4f\n", myMin->iter, pcm->nPix, t1, t2, t3, t4, t5);
+     }
 
     psFree(myMin);
@@ -121 +139 @@
 }
 
+// XXX deprecate this function or merge with the empirical model
 bool pmSourceModelGuessPCM (pmPCMdata *pcm, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal) {
 

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO.c

@@ -57 +57 @@
 #define BLANK_HEADERS "BLANK.HEADERS"   // Name of metadata in camera configuration containing header names
                                         // for putting values into a blank PHU
+static bool pmReadoutReadXSRC(pmFPAfile *file, char * exttype, psMetadata *hduHeader, psString xsrcname, psArray *sources, long *sourceIndex);
+static bool pmReadoutReadXFIT(pmFPAfile *file, char * exttype, psMetadata *hduHeader, psString xfitname, psArray *sources, long *sourceIndex);
+static bool pmReadoutReadXRAD(pmFPAfile *file, pmReadout *readout, char * exttype, psMetadata *hduHeader, psString xfitname, psArray *sources, long *sourceIndex);
 
 // lookup the EXTNAME values used for table data and image header segments
@@ -569 +572 @@
             PM_SOURCES_WRITE("PS1_V2",    CMF_PS1_V2);
             PM_SOURCES_WRITE("PS1_V3",    CMF_PS1_V3);
+            PM_SOURCES_WRITE("PS1_V4",    CMF_PS1_V4);
             PM_SOURCES_WRITE("PS1_SV1",   CMF_PS1_SV1);
             PM_SOURCES_WRITE("PS1_DV1",   CMF_PS1_DV1);
@@ -960 +964 @@
         psString dataname = NULL;
         psString deteffname = NULL;
-        if (!pmSourceIOextnames(&headname, &dataname, &deteffname, NULL, NULL, NULL, file, view)) {
+        psString xsrcname = NULL;
+        psString xfitname = NULL;
+        psString xradname = NULL;
+
+        // determine the output table format. Assume if we need to output extendend source
+        // parameters that they may exist in the input. 
+        // XXX: Perhaps we should use different recipe values.
+        // I.E. EXTENDED_SOURCE_ANALYSIS_READ or something like that
+        psMetadata *recipe = psMetadataLookupMetadata(&status, config->recipes, "PSPHOT");
+        if (!status) {
+            psError(PS_ERR_UNKNOWN, true, "missing recipe PSPHOT in config data");
+            return false;
+        }
+        // if this is not TRUE, the output files only contain the psf measurements.
+        bool XSRC_OUTPUT = psMetadataLookupBool(&status, recipe, "EXTENDED_SOURCE_ANALYSIS");
+        bool XFIT_OUTPUT = psMetadataLookupBool(&status, recipe, "EXTENDED_SOURCE_FITS");
+        bool XRAD_OUTPUT = psMetadataLookupBool(&status, recipe, "RADIAL_APERTURES");
+
+        if (!pmSourceIOextnames(&headname, &dataname, &deteffname, 
+                XSRC_OUTPUT ? &xsrcname : NULL, 
+                XFIT_OUTPUT ? &xfitname : NULL, 
+                XRAD_OUTPUT ? &xradname : NULL,
+                file, view)) {
             return false;
         }
@@ -1025 +1051 @@
                 sources = pmSourcesRead_CMF_PS1_V3 (file->fits, hdu->header);
             }
+            if (!strcmp (exttype, "PS1_V4")) {
+                sources = pmSourcesRead_CMF_PS1_V4 (file->fits, hdu->header);
+            }
             if (!strcmp (exttype, "PS1_SV1")) {
                 sources = pmSourcesRead_CMF_PS1_SV1 (file->fits, hdu->header);
@@ -1034 +1063 @@
                 sources = pmSourcesRead_CMF_PS1_DV2 (file->fits, hdu->header);
             }
+
+            long *sourceIndex = NULL;
+            if (XSRC_OUTPUT || XFIT_OUTPUT || XRAD_OUTPUT) {
+                long seq_max = -1;
+                for (long i = sources->n -1; i >= 0; i--) {
+                    pmSource *source = sources->data[i];
+                    if (source->seq > seq_max) {
+                        seq_max = source->seq;
+                    }
+                }
+                sourceIndex = psAlloc((seq_max + 1) * sizeof(long));
+                for (long i = 0; i < seq_max; i++) {
+                    sourceIndex[i] = -1;
+                }
+                for (long i = 0; i < sources->n; i++) {
+                    pmSource *source = sources->data[i];
+                    sourceIndex[source->seq] = i;
+                }
+            }
+            if (XSRC_OUTPUT && xsrcname) {
+                if (!pmReadoutReadXSRC(file, exttype, hdu->header, xsrcname, sources, sourceIndex)) {
+                    // XXX: is this an error?
+                    psErrorClear();
+                }
+                psFree(xsrcname);
+            }
+            if (XFIT_OUTPUT && xfitname) {
+                if (!pmReadoutReadXFIT(file, exttype, hdu->header, xfitname, sources, sourceIndex)) {
+                    // XXX: is this an error?
+                    psErrorClear();
+                }
+                psFree(xfitname);
+            }
+            if (XRAD_OUTPUT && xradname) {
+                if (!pmReadoutReadXRAD(file, readout, exttype, hdu->header, xradname, sources, sourceIndex)) {
+                    // XXX: is this an error?
+                    psErrorClear();
+                }
+                psFree(xradname);
+            }
+            psFree(sourceIndex);
 
             if (!pmReadoutReadDetEff(file->fits, readout, deteffname)) {
@@ -1161 +1231 @@
 }
 
-
+// XXX: We might be able to macroize this and reuse for the other types
+
+static bool pmReadoutReadXSRC(pmFPAfile *file, char *exttype, psMetadata *hduHeader, psString xsrcname, psArray *sources, long *sourceIndex) 
+{
+    if (!psFitsMoveExtName (file->fits, xsrcname)) {
+        psError(PS_ERR_UNKNOWN, false, "cannot find xsrc extension %s in %s", xsrcname, file->filename);
+        return false;
+    }
+
+    psMetadata *tableHeader = psFitsReadHeader(NULL, file->fits); // The FITS header
+    if (!tableHeader) psAbort("cannot read table header");
+
+    char *xtension = psMetadataLookupStr (NULL, tableHeader, "XTENSION");
+    if (!xtension) psAbort("cannot read table type");
+    if (strcmp (xtension, "BINTABLE")) {
+        psWarning ("no binary table in extension %s, skipping\n", xsrcname);
+        return false;
+    }
+
+    // XXX these are case-sensitive since the EXTYPE is case-sensitive
+    bool status = false;
+    if (file->type == PM_FPA_FILE_CMF) {
+        if (!strcmp (exttype, "PS1_SV1")) {
+            status  = pmSourcesRead_CMF_PS1_SV1_XSRC (file->fits, hduHeader, sources, sourceIndex);
+        }
+    }
+    psFree(tableHeader);
+    return status;
+}
+
+static bool pmReadoutReadXFIT(pmFPAfile *file, char *exttype, psMetadata *hduHeader, psString extname, psArray *sources, long *sourceIndex) 
+{
+    if (!psFitsMoveExtName (file->fits, extname)) {
+        psError(PS_ERR_UNKNOWN, false, "cannot find extension %s in %s", extname, file->filename);
+        return false;
+    }
+
+    psMetadata *tableHeader = psFitsReadHeader(NULL, file->fits); // The FITS header
+    if (!tableHeader) psAbort("cannot read table header");
+
+    char *xtension = psMetadataLookupStr (NULL, tableHeader, "XTENSION");
+    if (!xtension) psAbort("cannot read table type");
+    if (strcmp (xtension, "BINTABLE")) {
+        psWarning ("no binary table in extension %s, skipping\n", extname);
+        return false;
+    }
+
+    // XXX these are case-sensitive since the EXTYPE is case-sensitive
+    bool status = false;
+    if (file->type == PM_FPA_FILE_CMF) {
+        if (!strcmp (exttype, "PS1_SV1")) {
+            status  = pmSourcesRead_CMF_PS1_SV1_XFIT (file->fits, hduHeader, sources, sourceIndex);
+        }
+    }
+    psFree(tableHeader);
+    return status;
+}
+static bool pmReadoutReadXRAD(pmFPAfile *file, pmReadout *readout, char *exttype, psMetadata *hduHeader, psString extname, psArray *sources, long *sourceIndex) 
+{
+    if (!psFitsMoveExtName (file->fits, extname)) {
+        psError(PS_ERR_UNKNOWN, false, "cannot find extension %s in %s", extname, file->filename);
+        return false;
+    }
+
+    psMetadata *tableHeader = psFitsReadHeader(NULL, file->fits); // The FITS header
+    if (!tableHeader) psAbort("cannot read table header");
+
+    char *xtension = psMetadataLookupStr (NULL, tableHeader, "XTENSION");
+    if (!xtension) psAbort("cannot read table type");
+    if (strcmp (xtension, "BINTABLE")) {
+        psWarning ("no binary table in extension %s, skipping\n", extname);
+        return false;
+    }
+
+    // XXX these are case-sensitive since the EXTYPE is case-sensitive
+    bool status = false;
+    if (file->type == PM_FPA_FILE_CMF) {
+        if (!strcmp (exttype, "PS1_SV1")) {
+            status  = pmSourcesRead_CMF_PS1_SV1_XRAD (file->fits, readout, hduHeader, sources, sourceIndex);
+        }
+    }
+    psFree(tableHeader);
+    return status;
+}

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO.h

@@ -62 +62 @@
 bool pmSourcesWrite_CMF_PS1_V3_XRAD(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe);
 
+bool pmSourcesWrite_CMF_PS1_V4(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe);
+bool pmSourcesWrite_CMF_PS1_V4_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe);
+bool pmSourcesWrite_CMF_PS1_V4_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname);
+bool pmSourcesWrite_CMF_PS1_V4_XRAD(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe);
+
 bool pmSourcesWrite_CMF_PS1_SV1(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe);
 bool pmSourcesWrite_CMF_PS1_SV1_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe);
@@ -86 +91 @@
 psArray *pmSourcesRead_CMF_PS1_V2 (psFits *fits, psMetadata *header);
 psArray *pmSourcesRead_CMF_PS1_V3 (psFits *fits, psMetadata *header);
+psArray *pmSourcesRead_CMF_PS1_V4 (psFits *fits, psMetadata *header);
 psArray *pmSourcesRead_CMF_PS1_SV1 (psFits *fits, psMetadata *header);
+bool pmSourcesRead_CMF_PS1_SV1_XSRC (psFits *fits, psMetadata *header, psArray *sources, long *);
+bool pmSourcesRead_CMF_PS1_SV1_XFIT (psFits *fits, psMetadata *header, psArray *sources, long *);
+bool pmSourcesRead_CMF_PS1_SV1_XRAD (psFits *fits, pmReadout *readout, psMetadata *header, psArray *sources, long *);
 psArray *pmSourcesRead_CMF_PS1_DV1 (psFits *fits, psMetadata *header);
 psArray *pmSourcesRead_CMF_PS1_DV2 (psFits *fits, psMetadata *header);

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_CMF.c.in

@@ -55 +55 @@
 // followed by a zero-size matrix, followed by the table data
 
-// # define MODE @CMFMODE@
 bool pmSourcesWrite_CMF_@CMFMODE@ (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe)
 {
@@ -128 +127 @@
 
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG",           PS_DATA_F32, "magnitude in standard aperture",             source->apMag);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RAW",       PS_DATA_F32, "magnitude in reported aperture",             source->apMagRaw);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RAW",       PS_DATA_F32, "magnitude in reported aperture",             source->apMagRaw);
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RADIUS",    PS_DATA_F32, "radius used for aperture mags",              outputs.apRadius);
         @<PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "PEAK_FLUX_AS_MAG", PS_DATA_F32, "Peak flux expressed as magnitude",           outputs.peakMag);
@@ -139 +138 @@
         @>PS1_V1@ psMetadataAdd (row, PS_LIST_TAIL, "DEC_PSF",          PS_DATA_F64, "PSF DEC coordinate (degrees)",               outputs.dec);
 
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "PEAK_FLUX_AS_MAG", PS_DATA_F32, "Peak flux expressed as magnitude",           outputs.peakMag);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "PEAK_FLUX_AS_MAG", PS_DATA_F32, "Peak flux expressed as magnitude",           outputs.peakMag);
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "SKY",              PS_DATA_F32, "Sky level",                                  source->sky);
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "SKY_SIGMA",        PS_DATA_F32, "Sigma of sky level",                         source->skyErr);
@@ -151 +150 @@
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA",        PS_DATA_F32, "PSF orientation angle",                      outputs.psfTheta);
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF",           PS_DATA_F32, "PSF coverage/quality factor (bad)",          source->pixWeightNotBad);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF_PERFECT",   PS_DATA_F32, "PSF coverage/quality factor (poor)",         source->pixWeightNotPoor);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF_PERFECT",   PS_DATA_F32, "PSF coverage/quality factor (poor)",         source->pixWeightNotPoor);
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "PSF_NDOF",         PS_DATA_S32, "degrees of freedom",                         outputs.nDOF);
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX",         PS_DATA_S32, "number of pixels in fit",                    outputs.nPix);
@@ -159 +158 @@
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_YY",       PS_DATA_F32, "second moments (Y*Y)",                       moments.Myy);
 
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3C",      PS_DATA_F32, "third momemt cos theta",                     moments.M_c3);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3S",      PS_DATA_F32, "third momemt sin theta",                     moments.M_s3);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4C",      PS_DATA_F32, "fourth momemt cos theta",                    moments.M_c4);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4S",      PS_DATA_F32, "fourth momemt sin theta",                    moments.M_s4);
-
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_R1",       PS_DATA_F32, "first radial moment",                        moments.Mrf);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_RH",       PS_DATA_F32, "half radial moment",                         moments.Mrh);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX",        PS_DATA_F32, "Kron Flux (in 2.5 R1)",                      moments.Krf);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_ERR",    PS_DATA_F32, "Kron Flux Error",                            moments.dKrf);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_INNER",  PS_DATA_F32, "Kron Flux (in 2.5 R1)",                      moments.Kinner);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_OUTER",  PS_DATA_F32, "Kron Flux (in 2.5 R1)",                      moments.Kouter);
-
-        // Do NOT write these : not consistent with the definition of PS1_V3 in Ohana/src/libautocode/dev/cmf-ps1-v3.d
-        // psMetadataAdd (row, PS_LIST_TAIL, "KRON_CORE_FLUX",   PS_DATA_F32, "Kron Flux (in 1.0 R1)",                      moments.KronCore);
-        // psMetadataAdd (row, PS_LIST_TAIL, "KRON_CORE_ERROR",  PS_DATA_F32, "Kron Error (in 1.0 R1)",                     moments.KronCoreErr);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3C",      PS_DATA_F32, "third momemt cos theta",                     moments.M_c3);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3S",      PS_DATA_F32, "third momemt sin theta",                     moments.M_s3);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4C",      PS_DATA_F32, "fourth momemt cos theta",                    moments.M_c4);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4S",      PS_DATA_F32, "fourth momemt sin theta",                    moments.M_s4);
+
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_R1",       PS_DATA_F32, "first radial moment",                        moments.Mrf);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_RH",       PS_DATA_F32, "half radial moment",                         moments.Mrh);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX",        PS_DATA_F32, "Kron Flux (in 2.5 R1)",                      moments.Krf);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_ERR",    PS_DATA_F32, "Kron Flux Error",                            moments.dKrf);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_INNER",  PS_DATA_F32, "Kron Flux (in 2.5 R1)",                      moments.Kinner);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_OUTER",  PS_DATA_F32, "Kron Flux (in 2.5 R1)",                      moments.Kouter);
+
+        @>PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "SKY_LIMIT_RAD",    PS_DATA_F32, "Radius where object hits sky",               source->skyRadius);
+        @>PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "SKY_LIMIT_FLUX",   PS_DATA_F32, "Flux / pix where object hits sky",           source->skyFlux);
+        @>PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "SKY_LIMIT_SLOPE",  PS_DATA_F32, "d(Flux/pix)/dRadius where object hits sky",  source->skySlope);
+
         @ALL@     psMetadataAdd (row, PS_LIST_TAIL, "FLAGS",            PS_DATA_U32, "psphot analysis flags",                      source->mode);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "FLAGS2",           PS_DATA_U32, "psphot analysis flags",                      source->mode2);
-        @=PS1_V3@ psMetadataAdd (row, PS_LIST_TAIL, "PADDING2",         PS_DATA_S32, "more padding", 0);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "FLAGS2",           PS_DATA_U32, "psphot analysis flags",                      source->mode2);
+        @>PS1_V2@ psMetadataAdd (row, PS_LIST_TAIL, "PADDING2",         PS_DATA_S32, "more padding", 0);
 
         // XXX not sure how to get this : need to load Nimages with weight?
@@ -222 +222 @@
 
 // read in a readout from the fits file
-psArray *pmSourcesRead_CMF_PS1_V3 (psFits *fits, psMetadata *header)
+psArray *pmSourcesRead_CMF_@CMFMODE@ (psFits *fits, psMetadata *header)
 {
     PS_ASSERT_PTR_NON_NULL(fits, false);
@@ -281 +281 @@
         // XXX use these to determine PAR[PM_PAR_I0]?
         @ALL@     source->psfMag    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG");
-        @ALL@     source->psfMagErr    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG");
+        @ALL@     source->psfMagErr = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG");
         @ALL@     source->apMag     = psMetadataLookupF32 (&status, row, "AP_MAG");
+        @>PS1_V2@ source->apMagRaw  = psMetadataLookupF32 (&status, row, "AP_MAG_RAW");
+
+        // XXX use these to determine PAR[PM_PAR_I0] if they exist?
+        @>PS1_V2@ source->psfFlux   = psMetadataLookupF32 (&status, row, "PSF_INST_FLUX");
+        @>PS1_V2@ source->psfFluxErr= psMetadataLookupF32 (&status, row, "PSF_INST_FLUX_SIG");
 
         // XXX this scaling is incorrect: does not include the 2 \pi AREA factor
@@ -288 +293 @@
         @ALL@     dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         @ALL@     float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
@@ -303 +308 @@
 
         @ALL@     source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF");
-        @=PS1_V3@ source->pixWeightNotPoor = psMetadataLookupF32 (&status, row, "PSF_QF_PERFECT");
+        @>PS1_V2@ source->pixWeightNotPoor = psMetadataLookupF32 (&status, row, "PSF_QF_PERFECT");
         @ALL@     source->crNsigma  = psMetadataLookupF32 (&status, row, "CR_NSIGMA");
         @ALL@     source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA");
@@ -321 +326 @@
         @ALL@     source->moments->Myy = psMetadataLookupF32 (&status, row, "MOMENTS_YY");
 
-        @=PS1_V3@ source->moments->Mrf         = psMetadataLookupF32 (&status, row, "MOMENTS_R1");
-        @=PS1_V3@ source->moments->Mrh         = psMetadataLookupF32 (&status, row, "MOMENTS_RH");
-        @=PS1_V3@ source->moments->KronFlux    = psMetadataLookupF32 (&status, row, "KRON_FLUX");
-        @=PS1_V3@ source->moments->KronFluxErr = psMetadataLookupF32 (&status, row, "KRON_FLUX_ERR");
-
-        @=PS1_V3@ source->moments->KronFinner  = psMetadataLookupF32 (&status, row, "KRON_FLUX_INNER");
-        @=PS1_V3@ source->moments->KronFouter  = psMetadataLookupF32 (&status, row, "KRON_FLUX_OUTER");
+        @>PS1_V2@ source->moments->Mrf         = psMetadataLookupF32 (&status, row, "MOMENTS_R1");
+        @>PS1_V2@ source->moments->Mrh         = psMetadataLookupF32 (&status, row, "MOMENTS_RH");
+        @>PS1_V2@ source->moments->KronFlux    = psMetadataLookupF32 (&status, row, "KRON_FLUX");
+        @>PS1_V2@ source->moments->KronFluxErr = psMetadataLookupF32 (&status, row, "KRON_FLUX_ERR");
+
+        @>PS1_V2@ source->moments->KronFinner  = psMetadataLookupF32 (&status, row, "KRON_FLUX_INNER");
+        @>PS1_V2@ source->moments->KronFouter  = psMetadataLookupF32 (&status, row, "KRON_FLUX_OUTER");
+
+        @>PS1_V3@ source->skyRadius            = psMetadataLookupF32 (&status, row, "SKY_LIMIT_RAD");
+        @>PS1_V3@ source->skyFlux              = psMetadataLookupF32 (&status, row, "SKY_LIMIT_FLUX");
+        @>PS1_V3@ source->skySlope             = psMetadataLookupF32 (&status, row, "SKY_LIMIT_SLOPE");
 
         // XXX we do not save all of the 3rd and 4th moment parameters. when we load in data,
         // we are storing enough information so the output will be consistent with the input
-        @=PS1_V3@ source->moments->Mxxx = +1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3C");
-        @=PS1_V3@ source->moments->Mxxy = 0.0;
-        @=PS1_V3@ source->moments->Mxyy = 0.0;
-        @=PS1_V3@ source->moments->Myyy = -1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3S");
-
-        @=PS1_V3@ source->moments->Mxxxx = +1.00 * psMetadataLookupF32 (&status, row, "MOMENTS_M4C");
-        @=PS1_V3@ source->moments->Mxxxy = 0.0;
-        @=PS1_V3@ source->moments->Mxxyy = 0.0;
-        @=PS1_V3@ source->moments->Mxyyy = -0.25 * psMetadataLookupF32 (&status, row, "MOMENTS_M4S");
-        @=PS1_V3@ source->moments->Myyyy = 0.0;
+        @>PS1_V2@ source->moments->Mxxx = +1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3C");
+        @>PS1_V2@ source->moments->Mxxy = 0.0;
+        @>PS1_V2@ source->moments->Mxyy = 0.0;
+        @>PS1_V2@ source->moments->Myyy = -1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3S");
+
+        @>PS1_V2@ source->moments->Mxxxx = +1.00 * psMetadataLookupF32 (&status, row, "MOMENTS_M4C");
+        @>PS1_V2@ source->moments->Mxxxy = 0.0;
+        @>PS1_V2@ source->moments->Mxxyy = 0.0;
+        @>PS1_V2@ source->moments->Mxyyy = -0.25 * psMetadataLookupF32 (&status, row, "MOMENTS_M4S");
+        @>PS1_V2@ source->moments->Myyyy = 0.0;
 
         @ALL@     source->mode = psMetadataLookupU32 (&status, row, "FLAGS");
-        @=PS1_V3@ source->mode2 = psMetadataLookupU32 (&status, row, "FLAGS2");
+        @>PS1_V2@ source->mode2 = psMetadataLookupU32 (&status, row, "FLAGS2");
         assert (status);
 
@@ -353 +362 @@
 }
 
-bool pmSourcesWrite_CMF_PS1_V3_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe)
+bool pmSourcesWrite_CMF_@CMFMODE@_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe)
 {
     bool status;
@@ -541 +550 @@
 
 // XXX this layout is still the same as PS1_DEV_1
-bool pmSourcesWrite_CMF_PS1_V3_XFIT (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname)
+bool pmSourcesWrite_CMF_@CMFMODE@_XFIT (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname)
 {
 
@@ -590 +599 @@
             assert (model);
 
+            // pmSourceExtFitPars *extPars = source->extFitPars->data[j];
+            // assert (extPars);
+
             // skip models which were not actually fitted
             if (model->flags & PM_MODEL_STATUS_BADARGS) continue;
@@ -600 +612 @@
             yErr = dPAR[PM_PAR_YPOS];
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
+
+            float kronFlux = source->moments ? source->moments->KronFlux : NAN;
+            float kronMag = isfinite(kronFlux) ? -2.5*log10(kronFlux) : NAN;
 
             row = psMetadataAlloc ();
@@ -612 +627 @@
             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, "MOMENTS_XX",       0, "second moment in x",                      extPars->Mxx);
+            // psMetadataAddF32 (row, PS_LIST_TAIL, "MOMENTS_XY",       0, "second moment in x,y",                    extPars->Mxy);
+            // psMetadataAddF32 (row, PS_LIST_TAIL, "MOMENTS_YY",       0, "second moment in y",                      extPars->Myy);
+            // psMetadataAddF32 (row, PS_LIST_TAIL, "MOMENTS_R1",       0, "first radial moment",                     extPars->Mrf);
+            // psMetadataAddF32 (row, PS_LIST_TAIL, "MOMENTS_RH",       0, "half radial moment",                      extPars->Mrh);
+
+            psMetadataAddF32 (row, PS_LIST_TAIL, "PSF_INST_MAG",     0, "PSF fit instrumental magnitude",             source->psfMag);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "AP_MAG",           0, "PSF-sized aperture magnitude",               source->apMag);
+            psMetadataAddF32 (row, PS_LIST_TAIL, "KRON_MAG",         0, "Kron Mag",                                   kronMag);
 
             psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS",          0, "number of model parameters",                 model->params->n);
@@ -673 +698 @@
 }
 
-bool pmSourcesWrite_CMF_PS1_V3_XRAD(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe)
+bool pmSourcesWrite_CMF_@CMFMODE@_XRAD(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe)
 {
     return true;

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_CMF_PS1_DV1.c

@@ -263 +263 @@
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
@@ -547 +547 @@
             yErr = dPAR[PM_PAR_YPOS];
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
             row = psMetadataAlloc ();

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_CMF_PS1_DV2.c

@@ -281 +281 @@
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
@@ -572 +572 @@
             yErr = dPAR[PM_PAR_YPOS];
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
             row = psMetadataAlloc ();

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_CMF_PS1_SV1.c

@@ -280 +280 @@
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
@@ -539 +539 @@
 }
 
+bool pmSourcesRead_CMF_PS1_SV1_XSRC(psFits *fits, psMetadata *hduHeader, psArray *sources, long *sourceIndex)
+{
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+    PS_ASSERT_PTR_NON_NULL(sources, false);
+
+    bool status;
+    long numSources = psFitsTableSize(fits); // Number of sources in table
+    if (numSources == 0) {
+        psError(psErrorCodeLast(), false, "XSRC Table contains no entries\n");
+        return false;
+    }
+
+    // petrosian mags are not saved, we need to calculate fluxes. For this we need exptime and zero point
+    float zeropt = psMetadataLookupF32(&status, hduHeader, "FPA.ZP");
+    float exptime = psMetadataLookupF32(&status, hduHeader, "EXPTIME");
+    float magOffset = zeropt + 2.5*log10(exptime);
+
+    for (long i = 0; i < numSources; i++) {
+        psMetadata *row = psFitsReadTableRow(fits, i); // Table row
+        if (!row) {
+            psError(psErrorCodeLast(), false, "Unable to read row %ld of sources", i);
+            psFree(row);
+            return false;
+        }
+        // Find the source with this sequence number. 
+        // XXX: I am assuming that sources is sorted in order of seq
+        long seq = psMetadataLookupU32 (&status, row, "IPP_IDET");
+        pmSource *source = NULL;
+#ifndef ASSUME_SORTED
+        long j = seq < sources->n ? seq : sources->n - 1;
+        for (; j >= 0; j--) {
+            source = sources->data[j];
+            if (source->seq == seq) {
+                break;
+            }
+        }
+#else
+        long j = sourceIndex[seq];
+        psAssert(j >= 0 && j < sources->n, "invalid sourceIndex");
+        source = sources->data[j];
+#endif
+        if (!source) {
+            psError(PS_ERR_UNKNOWN, false, "Failed to find source for row %ld sequence number %ld\n", i, seq);
+            psFree(row);
+            return false;
+        }
+
+        if (!source->extpars) {
+            source->extpars = pmSourceExtendedParsAlloc ();
+        }
+        pmSourceExtendedPars *extpars = source->extpars;
+
+        // Assume that X_EXT Y_EXT and sigmas match the psf src so skip
+
+        // We don't have enough information to calculate the major and minor axis. Set major to 1. Should we scale this by
+        // psf size or something?
+        extpars->axes.major = 1.0;
+        extpars->axes.minor = extpars->axes.major * psMetadataLookupF32(&status, row, "F25_ARATIO");
+        extpars->axes.theta = psMetadataLookupF32(&status, row, "F25_THETA");
+
+        float mag = psMetadataLookupF32(&status, row, "PETRO_MAG");
+        float magErr = psMetadataLookupF32(&status, row, "PETRO_MAG_ERR");
+        if (isfinite(mag)) {
+            extpars->petrosianFlux    = pow(10., (magOffset - mag) / 2.5);
+            if (isfinite(magErr)) {
+                extpars->petrosianFluxErr = extpars->petrosianFlux / magErr;
+            }
+        }
+
+        extpars->petrosianRadius   = psMetadataLookupF32(&status, row, "PETRO_RADIUS");
+        extpars->petrosianRadiusErr= psMetadataLookupF32(&status, row, "PETRO_RADIUS_ERR");
+        extpars->petrosianR50      = psMetadataLookupF32(&status, row, "PETRO_RADIUS_50");
+        extpars->petrosianR50Err   = psMetadataLookupF32(&status, row, "PETRO_RADIUS_50_ERR");
+        extpars->petrosianR90      = psMetadataLookupF32(&status, row, "PETRO_RADIUS_90");
+        extpars->petrosianR90Err   = psMetadataLookupF32(&status, row, "PETRO_RADIUS_90_ERR");
+        extpars->petrosianFill     = psMetadataLookupF32(&status, row, "PETRO_FILL");
+
+        psVector *radSB   = psMetadataLookupVector(&status, row, "PROF_SB");
+        psVector *radFlux = psMetadataLookupVector(&status, row, "PROF_FLUX");
+        psVector *radFill = psMetadataLookupVector(&status, row, "PROF_FILL");
+
+        if (radSB && radSB->n > 0) {
+            extpars->radProfile = pmSourceRadialProfileAlloc();
+            extpars->radProfile->binSB   = psMemIncrRefCounter(radSB);
+            extpars->radProfile->binSum   = psMemIncrRefCounter(radFlux);
+            extpars->radProfile->binFill = psMemIncrRefCounter(radFill);
+        }
+
+        psFree(row);
+    }
+
+    return true;
+}
+
 // XXX this layout is still the same as PS1_DEV_1
 bool pmSourcesWrite_CMF_PS1_SV1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname)
@@ -607 +701 @@
             yErr = dPAR[PM_PAR_YPOS];
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
             row = psMetadataAlloc ();
@@ -684 +778 @@
     psFree (outhead);
     psFree (table);
+    return true;
+}
+
+bool pmSourcesRead_CMF_PS1_SV1_XFIT(psFits *fits, psMetadata *hduHeader, psArray *sources, long *sourceIndex)
+{
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+    PS_ASSERT_PTR_NON_NULL(sources, false);
+
+    bool status;
+    long numSources = psFitsTableSize(fits); // Number of sources in table
+    if (numSources == 0) {
+        psError(psErrorCodeLast(), false, "XFIT Table contains no entries\n");
+        return false;
+    }
+
+    for (long i = 0; i < numSources; i++) {
+        psMetadata *row = psFitsReadTableRow(fits, i); // Table row
+        if (!row) {
+            psError(psErrorCodeLast(), false, "Unable to read row %ld of sources", i);
+            psFree(row);
+            return false;
+        }
+        // Find the source with this sequence number. 
+        // XXX: I am assuming that sources is sorted in order of seq.
+        long seq = psMetadataLookupU32 (&status, row, "IPP_IDET");
+        long j = seq < sources->n ? seq : sources->n - 1;
+        pmSource *source = NULL;
+        for (; j >= 0; j--) {
+            source = sources->data[j];
+            if (source->seq == seq) {
+                break;
+            }
+        }
+        if (!source) {
+            psError(PS_ERR_UNKNOWN, false, "Failed to find source for row %ld sequence number %ld\n", i, seq);
+            psFree(row);
+            return false;
+        }
+        if (!source->modelFits) {
+            // XXX: where to find the number of models to expect?
+            source->modelFits = psArrayAllocEmpty(5);
+        }
+        psString modelName = psMetadataLookupStr(&status, row, "MODEL_TYPE");
+        if (!modelName) {
+            psError(PS_ERR_UNKNOWN, true, "Failed to find model name for row %ld\n", i);
+            psFree(row);
+            return false;
+        }
+        pmModelType modelType = pmModelClassGetType(modelName);
+        if (modelType < 0) {
+            psError(PS_ERR_UNKNOWN, true, "Failed to find model type for %s\n", modelName);
+            psFree(row);
+            return false;
+        }
+        pmModel *model = pmModelAlloc(modelType);
+
+        psF32 *PAR = model->params->data.F32;
+        psF32 *dPAR = model->dparams->data.F32;
+
+        PAR[PM_PAR_XPOS] = psMetadataLookupF32(&status, row, "X_EXT");
+        PAR[PM_PAR_YPOS] = psMetadataLookupF32(&status, row, "Y_EXT");
+        dPAR[PM_PAR_XPOS] = psMetadataLookupF32(&status, row, "X_EXT_SIG");
+        dPAR[PM_PAR_YPOS] = psMetadataLookupF32(&status, row, "Y_EXT_SIG");
+
+        model->mag = psMetadataLookupF32(&status, row, "EXT_INST_MAG");
+        model->magErr = psMetadataLookupF32(&status, row, "EXT_INST_MAG_SIG");
+
+        psEllipseAxes axes;
+        axes.major = psMetadataLookupF32(&status, row, "EXT_WIDTH_MAJ");
+        axes.minor = psMetadataLookupF32(&status, row, "EXT_WIDTH_MIN");
+        axes.theta = psMetadataLookupF32(&status, row, "EXT_THETA");
+        if (!pmPSF_AxesToModel(PAR, axes, modelType)) {
+            // Do we need to fail here or can this happen?
+            psError(PS_ERR_UNKNOWN, false, "Failed to convert psf axes to model");
+            psFree(model);
+            psFree(row);
+            return false;
+        }
+        // XXX: clean this up
+        if (model->params->n > 7) {
+            PAR[7] = psMetadataLookupF32(&status, row, "EXT_PAR_07");
+        }
+        // read the covariance matrix
+        int nparams = model->params->n;
+        psImage *covar = psImageAlloc(nparams, nparams, PS_TYPE_F32);
+        for (int y = 0; y < nparams; y++) {
+            for (int x = 0; x < nparams; x++) {
+                char name[64];
+                snprintf(name, 64, "EXT_COVAR_%02d_%02d", y, x);
+                covar->data.F32[y][x] = psMetadataLookupF32(&status, row, name);
+            }
+        }
+        model->covar = covar;
+
+        psArrayAdd(source->modelFits, 1, model);
+        psFree(model);
+
+        psFree(row);
+    }
+
     return true;
 }
@@ -831 +1025 @@
     return true;
 }
+
+bool pmSourcesRead_CMF_PS1_SV1_XRAD(psFits *fits, pmReadout *readout, psMetadata *hduHeader, psArray *sources, long *sourceIndex)
+{
+    PS_ASSERT_PTR_NON_NULL(fits, false);
+    PS_ASSERT_PTR_NON_NULL(sources, false);
+
+    bool status;
+    long numSources = psFitsTableSize(fits); // Number of sources in table
+    if (numSources == 0) {
+        psError(psErrorCodeLast(), false, "XRAD Table contains no entries\n");
+        return false;
+    }
+
+    long       seq_first = -1;
+    long       seq_last = -1;
+    psVector   *fwhmValues = psVectorAllocEmpty(10, PS_TYPE_F32);
+    long       max_entries = -1;
+    long       num_entries = -1;
+
+    for (long i = 0; i < numSources; i++) {
+        psMetadata *row = psFitsReadTableRow(fits, i); // Table row
+        if (!row) {
+            psError(psErrorCodeLast(), false, "Unable to read row %ld of sources", i);
+            psFree(row);
+            return false;
+        }
+        // Find the source with this sequence number. 
+        // XXX: I am assuming that sources is sorted in order of seq.
+        long seq = psMetadataLookupU32 (&status, row, "IPP_IDET");
+        long j = seq < sources->n ? seq : sources->n - 1;
+        pmSource *source = NULL;
+        for (; j >= 0; j--) {
+            source = sources->data[j];
+            if (source->seq == seq) {
+                break;
+            }
+        }
+        if (!source) {
+            psError(PS_ERR_UNKNOWN, false, "Failed to find source for row %ld sequence number %ld\n", i, seq);
+            psFree(row);
+            return false;
+        }
+        if (seq_first == -1) {
+            seq_first = seq;
+        }
+        if (seq == seq_first) {
+            psF32 value = psMetadataLookupF32(&status, row, "PSF_FWHM");
+            psVectorAppend(fwhmValues, value);
+        }
+        if (seq == seq_last) {
+            num_entries++;
+        } else {
+            num_entries = 1;
+            seq_last = seq;
+        }
+        if (num_entries > max_entries) {
+            max_entries = num_entries;
+        }
+
+        if (!source->radialAper) {
+            // XXX: where to find the number of models to expect?
+            source->radialAper = psArrayAllocEmpty(5);
+        }
+        pmSourceRadialApertures *radialAper = pmSourceRadialAperturesAlloc();
+
+        radialAper->flux = psMemIncrRefCounter(psMetadataLookupVector(&status, row, "APER_FLUX"));
+        radialAper->fluxStdev = psMemIncrRefCounter(psMetadataLookupVector(&status, row, "APER_FLUX_STDEV"));
+        radialAper->fluxErr = psMemIncrRefCounter(psMetadataLookupVector(&status, row, "APER_FLUX_ERR"));
+        radialAper->fill = psMemIncrRefCounter(psMetadataLookupVector(&status, row, "APER_FILL"));
+
+        psArrayAdd(source->radialAper, 1, radialAper);
+
+        psFree(radialAper);
+        psFree(row);
+    }
+
+    // check for consistency between the length of fwhmValues and the maximum number of entries for each row
+    if (fwhmValues->n != max_entries) {
+        psError(PS_ERR_PROGRAMMING, true, "number of PSF_FWHM values found %ld does not match expected number: %ld\n",
+            fwhmValues->n, max_entries);
+        psAssert(0, "fixme");
+    }
+
+    if (!readout->analysis) {
+        readout->analysis = psMetadataAlloc();
+    }
+
+    psMetadataAddVector(readout->analysis, PS_LIST_TAIL, "STACK.PSF.FWHM.VALUES", PS_META_REPLACE, "PSF sizes", fwhmValues);
+    psFree(fwhmValues);
+
+    return true;
+}

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_CMP.c

@@ -135 +135 @@
         lsky = (source->sky < 1.0) ? 0.0 : log10(source->sky);
 
-        axes = pmPSF_ModelToAxes (PAR, 20.0);
+        axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
         float psfMagErr = isfinite(source->psfMagErr) ? source->psfMagErr : 999;
@@ -293 +293 @@
                 goto skip_source;
 
-            pmPSF_AxesToModel (PAR, axes);
+            pmPSF_AxesToModel (PAR, axes, modelType);
 
             psArrayAdd (sources, 100, source);

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_OBJ.c

@@ -91 +91 @@
         }
 
-        axes = pmPSF_ModelToAxes (PAR, 20.0);
+        axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
         psLineInit (line);

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_PS1_CAL_0.c

@@ -113 +113 @@
             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);
+                axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
             } else {
                 axes.major = NAN;
@@ -288 +288 @@
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
@@ -618 +618 @@
             yErr = dPAR[PM_PAR_YPOS];
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
             // generate RA,DEC

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_PS1_DEV_0.c

@@ -89 +89 @@
             yErr = dPAR[PM_PAR_YPOS];
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
         } else {
             // XXX: This code seg faults if source->peak is NULL.
@@ -214 +214 @@
         source->psfMagErr    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG");
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         float peakMag = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_PS1_DEV_1.c

@@ -95 +95 @@
             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);
+                axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
             } else {
                 axes.major = NAN;
@@ -257 +257 @@
         dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
@@ -522 +522 @@
             yErr = dPAR[PM_PAR_YPOS];
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
             row = psMetadataAlloc ();

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_SMPDATA.c

@@ -92 +92 @@
             lsky = (source->sky < 1.0) ? 0.0 : log10(source->sky);
 
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
         } else {
@@ -190 +190 @@
         axes.theta       = psMetadataLookupF32 (&status, row, "THETA");
 
-        pmPSF_AxesToModel (PAR, axes);
+        pmPSF_AxesToModel (PAR, axes, modelType);
 
         source->psfMag = psMetadataLookupF32 (&status, row, "MAG_RAW") - ZERO_POINT;

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceIO_SX.c

@@ -81 +81 @@
         // pmSourceSextractType (source, &type, &flags);
 
-        axes = pmPSF_ModelToAxes (PAR, 20.0);
+        axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
         psLineInit (line);

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceMasks.h

@@ -46 +46 @@
     PM_SOURCE_MODE2_DIFF_WITH_DOUBLE = 0x00000002, ///< diff source matched to positive detections in both images
     PM_SOURCE_MODE2_MATCHED          = 0x00000004, ///< diff source matched to positive detections in both images
+    PM_SOURCE_MODE2_DIFF_SELF_MATCH  = 0x00000800, ///< positive detection match is probably this source 
 
     PM_SOURCE_MODE2_ON_SPIKE         = 0x00000008, ///< > 25% of (PSF-weighted) pixels land on diffraction spike

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceMoments.c

@@ -96 +96 @@
     // (int) so they can be used in the image index below.
 
-    // do 2 passes : the first pass should use a somewhat smaller radius and no sigma window to 
-    // get an unbiased (but probably noisy) centroid
-    if (!pmSourceMomentsGetCentroid (source, 0.75*radius, 0.0, minSN, maskVal, source->peak->xf, source->peak->yf)) {
-        return false;
-    }
-    // second pass applies the Gaussian window and uses the centroid from the first pass
-    if (!pmSourceMomentsGetCentroid (source, radius, sigma, minSN, maskVal, source->moments->Mx, source->moments->My)) {
+    // XXX // do 2 passes : the first pass should use a somewhat smaller radius and no sigma window to 
+    // XXX // get an unbiased (but probably noisy) centroid
+    // XXX if (!pmSourceMomentsGetCentroid (source, 0.75*radius, 0.0, minSN, maskVal, source->peak->xf, source->peak->yf)) {
+    // XXX      return false;
+    // XXX }
+    // XXX // second pass applies the Gaussian window and uses the centroid from the first pass
+    // XXX if (!pmSourceMomentsGetCentroid (source, radius, sigma, minSN, maskVal, source->moments->Mx, source->moments->My)) {
+    // XXX      return false;
+    // XXX }
+
+    // If we use a large radius for the centroid, it will be biased by any neighbors.  The flux
+    // of any object drops pretty quickly outside 1-2 sigmas.  (The exception is bright
+    // saturated stars, for which we need to use a very large radius here)
+    if (!pmSourceMomentsGetCentroid (source, 1.5*sigma, 0.0, minSN, maskVal, source->peak->xf, source->peak->yf)) {
         return false;
     }
@@ -108 +115 @@
     // Now calculate higher-order moments, using the above-calculated first moments to adjust coordinates
     // Xn  = SUM (x - xc)^n * (z - sky)
-
-    float RFW = 0.0;
-    float RHW = 0.0;
-
-    float RF = 0.0;
-    float RH = 0.0;
-    float RS = 0.0;
     float XX = 0.0;
     float XY = 0.0;
@@ -143 +143 @@
     float yCM = Yo - 0.5 - source->pixels->row0; // coord of peak in subimage
 
+    // calculate the higher-order moments using Xo,Yo
     for (psS32 row = 0; row < source->pixels->numRows ; row++) {
 
@@ -194 +195 @@
             Sum += pDiff;
 
-            // Kron Flux uses the 1st radial moment (NOT Gaussian windowed?)
             float r = sqrt(r2);
-            float rf = r * fDiff;
-            float rh = sqrt(r) * fDiff;
-            float rs = fDiff;
-
-            float rfw = r * pDiff;
-            float rhw = sqrt(r) * pDiff;
 
             float x = xDiff * pDiff;
@@ -221 +215 @@
             float yyyy = yDiff * yyy / r2;
 
-            RF  += rf;
-            RH  += rh;
-            RS  += rs;
-
-            RFW  += rfw;
-            RHW  += rhw;
-
             XX  += xx;
             XY  += xy;
@@ -242 +229 @@
             XYYY  += xyyy;
             YYYY  += yyyy;
+
+            // Kron Flux uses the 1st radial moment (NOT Gaussian windowed?)
+            // XXX float r = sqrt(r2);
+            // XXX float rf = r * fDiff;
+            // XXX float rh = sqrt(r) * fDiff;
+            // XXX float rs = fDiff;
+            // XXX 
+            // XXX float rfw = r * pDiff;
+            // XXX float rhw = sqrt(r) * pDiff;
+            // XXX 
+            // XXX RF  += rf;
+            // XXX RH  += rh;
+            // XXX RS  += rs;
+            // XXX 
+            // XXX RFW  += rfw;
+            // XXX RHW  += rhw;
         }
     }
-
-    source->moments->Mrf = RF/RS;
-    source->moments->Mrh = RH/RS;
-
     source->moments->Mxx = XX/Sum;
     source->moments->Mxy = XY/Sum;
@@ -262 +261 @@
     source->moments->Mxyyy = XYYY/Sum;
     source->moments->Myyyy = YYYY/Sum;
+
+    // *** now calculate the 1st radial moment (for kron flux) -- symmetrical averaging
+
+    float **vPix = source->pixels->data.F32;
+    float **vWgt = source->variance->data.F32;
+    psImageMaskType  **vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA;
+
+    float RF = 0.0;
+    float RH = 0.0;
+    float RS = 0.0;
+
+    for (psS32 row = 0; row < source->pixels->numRows ; row++) {
+
+        float yDiff = row - yCM;
+        if (fabs(yDiff) > radius) continue;
+
+        // coordinate of mirror pixel
+        int yFlip = yCM - yDiff;
+        if (yFlip < 0) continue;
+        if (yFlip >= source->pixels->numRows) continue;
+
+        for (psS32 col = 0; col < source->pixels->numCols ; col++) {
+            // check mask and value for this pixel
+            if (vMsk && (vMsk[row][col] & maskVal)) continue;
+            if (isnan(vPix[row][col])) continue;
+
+            float xDiff = col - xCM;
+            if (fabs(xDiff) > radius) continue;
+
+            // coordinate of mirror pixel
+            int xFlip = xCM - xDiff;
+            if (xFlip < 0) continue;
+            if (xFlip >= source->pixels->numCols) continue;
+
+            // check mask and value for mirror pixel
+            if (vMsk && (vMsk[yFlip][xFlip] & maskVal)) continue;
+            if (isnan(vPix[yFlip][xFlip])) continue;
+
+            // radius is just a function of (xDiff, yDiff)
+            float r2  = PS_SQR(xDiff) + PS_SQR(yDiff);
+            if (r2 > R2) continue;
+
+            float fDiff1 = vPix[row][col] - sky;
+            float fDiff2 = vPix[yFlip][xFlip] - sky;
+            float pDiff = (fDiff1 > 0.0) ? sqrt(fabs(fDiff1*fDiff2)) : -sqrt(fabs(fDiff1*fDiff2));
+
+            // Kron Flux uses the 1st radial moment (NOT Gaussian windowed?)
+            float r = sqrt(r2);
+            float rf = r * pDiff;
+            float rh = sqrt(r) * pDiff;
+            float rs = 0.5 * (fDiff1 + fDiff2);
+
+            RF  += rf;
+            RH  += rh;
+            RS  += rs;
+        }
+    }
+
+    source->moments->Mrf = RF/RS;
+    source->moments->Mrh = RH/RS;
 
     // if Mrf (first radial moment) is very small, we are getting into low-significance
@@ -270 +329 @@
         kronRefRadius = MIN(radius, kronRefRadius);
     }
+
+    // *** now calculate the kron flux values using the 1st radial moment
 
     float radKinner = 1.0*kronRefRadius;
@@ -283 +344 @@
     float SumOuter = 0.0;
 
+    // calculate the Kron flux, and related fluxes (NO symmetrical averaging)
     for (psS32 row = 0; row < source->pixels->numRows ; row++) {
-
+        
         float yDiff = row - yCM;
         if (fabs(yDiff) > radKouter) continue;
+        
+        for (psS32 col = 0; col < source->pixels->numCols ; col++) {
+            // check mask and value for this pixel
+            if (vMsk && (vMsk[row][col] & maskVal)) continue;
+            if (isnan(vPix[row][col])) continue;
+            
+            float xDiff = col - xCM;
+            if (fabs(xDiff) > radKouter) continue;
+            
+            // radKron is just a function of (xDiff, yDiff)
+            float r2  = PS_SQR(xDiff) + PS_SQR(yDiff);
+
+            float fDiff1 = vPix[row][col] - sky;
+            float pDiff = fDiff1;
+            float wDiff = vWgt[row][col];
+                                    
+            // skip pixels below specified significance level.  this is allowed, but should be
+            // avoided -- the over-weights the wings of bright stars compared to those of faint
+            // stars.
+            if (PS_SQR(pDiff) < minSN2*wDiff) continue;
+            
+            float r  = sqrt(r2);
+            if (r < radKron) {
+                Sum += pDiff;
+                Var += wDiff;
+                nKronPix ++;
+                // if (beVerbose) fprintf (stderr, "mome: %d %d  %f  %f  %f\n", col, row, sky, *vPix, Sum);
+            }
+
+            // use sigma (fixed by psf) not a radKron based value
+            if (r < sigma) {
+                SumCore += pDiff;
+                VarCore += wDiff;
+                nCorePix ++;
+            }
+
+            if ((r > radKinner) && (r < radKron)) {
+                SumInner += pDiff;
+                nInner ++;
+            }
+            if ((r > radKron)  && (r < radKouter)) {
+                SumOuter += pDiff;
+                nOuter ++;
+            }
+        }
+    }
+    // *** should I rescale these fluxes by pi R^2 / nNpix?
+    // XXX source->moments->KronCore    = SumCore       * M_PI * PS_SQR(sigma) / nCorePix;
+    // XXX source->moments->KronCoreErr = sqrt(VarCore) * M_PI * PS_SQR(sigma) / nCorePix;
+    // XXX source->moments->KronFlux    = Sum       * M_PI * PS_SQR(radKron) / nKronPix;
+    // XXX source->moments->KronFluxErr = sqrt(Var) * M_PI * PS_SQR(radKron) / nKronPix;
+    // XXX source->moments->KronFinner = SumInner * M_PI * (PS_SQR(radKron)   - PS_SQR(radKinner)) / nInner;
+    // XXX source->moments->KronFouter = SumOuter * M_PI * (PS_SQR(radKouter) -   PS_SQR(radKron)) / nOuter;
+
+    source->moments->KronCore    = SumCore;
+    source->moments->KronCoreErr = sqrt(VarCore);
+    source->moments->KronFlux    = Sum;
+    source->moments->KronFluxErr = sqrt(Var);
+    source->moments->KronFinner = SumInner;
+    source->moments->KronFouter = SumOuter;
+
+    // XXX not sure I should save this here...
+    source->moments->KronFluxPSF    = source->moments->KronFlux;
+    source->moments->KronFluxPSFErr = source->moments->KronFluxErr;
+    source->moments->KronRadiusPSF  = source->moments->Mrf;
+
+    psTrace ("psModules.objects", 4, "Mrf: %f  KronFlux: %f  Mxx: %f  Mxy: %f  Myy: %f  Mxxx: %f  Mxxy: %f  Mxyy: %f  Myyy: %f  Mxxxx: %f  Mxxxy: %f  Mxxyy: %f  Mxyyy: %f  Mxyyy: %f\n",
+             source->moments->Mrf,   source->moments->KronFlux, 
+             source->moments->Mxx,   source->moments->Mxy,   source->moments->Myy,
+             source->moments->Mxxx,  source->moments->Mxxy,  source->moments->Mxyy,  source->moments->Myyy,
+             source->moments->Mxxxx, source->moments->Mxxxy, source->moments->Mxxyy, source->moments->Mxyyy, source->moments->Myyyy);
+
+    psTrace ("psModules.objects", 3, "peak %f %f (%f = %f) Mx: %f  My: %f  Sum: %f  Mxx: %f  Mxy: %f  Myy: %f  sky: %f  Npix: %d\n",
+             source->peak->xf, source->peak->yf, source->peak->rawFlux, sqrt(source->peak->detValue), source->moments->Mx,   source->moments->My, Sum, source->moments->Mxx,   source->moments->Mxy,   source->moments->Myy, sky, source->moments->nPixels);
+
+    return(true);
+}
+
+bool pmSourceMomentsGetCentroid(pmSource *source, float radius, float sigma, float minSN, psImageMaskType maskVal, float xGuess, float yGuess) { 
+
+    // First Pass: calculate the first moments (these are subtracted from the coordinates below)
+    // Sum = SUM (z - sky)
+    // X1  = SUM (x - xc)*(z - sky)
+    // .. etc
+
+    float sky = 0.0;
+
+    float peakPixel = -PS_MAX_F32;
+    psS32 numPixels = 0;
+    float Sum = 0.0;
+    float Var = 0.0;
+    float X1 = 0.0;
+    float Y1 = 0.0;
+    float R2 = PS_SQR(radius);
+    float minSN2 = PS_SQR(minSN);
+    float rsigma2 = 0.5 / PS_SQR(sigma);
+
+    float xPeak = xGuess - source->pixels->col0; // coord of peak in subimage
+    float yPeak = yGuess - source->pixels->row0; // coord of peak in subimage
+
+    // we are guaranteed to have a valid pixel and variance at this location (right? right?)
+    // float weightNorm = source->pixels->data.F32[yPeak][xPeak] / sqrt (source->variance->data.F32[yPeak][xPeak]);
+    // psAssert (isfinite(source->pixels->data.F32[yPeak][xPeak]), "peak must be on valid pixel");
+    // psAssert (isfinite(source->variance->data.F32[yPeak][xPeak]), "peak must be on valid pixel");
+    // psAssert (source->variance->data.F32[yPeak][xPeak] > 0, "peak must be on valid pixel");
+
+    // the moments [Sum(x*f) / Sum(f)] are calculated in pixel index values, and should
+    // not depend on the fractional pixel location of the source.  However, the aperture
+    // (radius) and the Gaussian window (sigma) depend subtly on the fractional pixel
+    // position of the expected centroid
+
+    for (psS32 row = 0; row < source->pixels->numRows ; row++) {
+
+        float yDiff = row + 0.5 - yPeak;
+        if (fabs(yDiff) > radius) continue;
 
         float *vPix = source->pixels->data.F32[row];
         float *vWgt = source->variance->data.F32[row];
 
-        psImageMaskType  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
-        // psImageMaskType  *vMsk = (source->maskView == NULL) ? NULL : source->maskView->data.PS_TYPE_IMAGE_MASK_DATA[row];
+        psImageMaskType *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
+        // psImageMaskType *vMsk = (source->maskView == NULL) ? NULL : source->maskView->data.PS_TYPE_IMAGE_MASK_DATA[row];
 
         for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) {
@@ -304 +481 @@
             if (isnan(*vPix)) continue;
 
-            float xDiff = col - xCM;
-            if (fabs(xDiff) > radKouter) continue;
-
-            // radKron is just a function of (xDiff, yDiff)
-            float r2  = PS_SQR(xDiff) + PS_SQR(yDiff);
-
-            float pDiff = *vPix - sky;
-            float wDiff = *vWgt;
-
-            // skip pixels below specified significance level.  this is allowed, but should be
-            // avoided -- the over-weights the wings of bright stars compared to those of faint
-            // stars.
-            if (PS_SQR(pDiff) < minSN2*wDiff) continue;
-
-            float r  = sqrt(r2);
-            if (r < radKron) {
-                Sum += pDiff;
-                Var += wDiff;
-                nKronPix ++;
-                // if (beVerbose) fprintf (stderr, "mome: %d %d  %f  %f  %f\n", col, row, sky, *vPix, Sum);
-            }
-
-            // use sigma (fixed by psf) not a radKron based value
-            if (r < sigma) {
-                SumCore += pDiff;
-                VarCore += wDiff;
-                nCorePix ++;
-            }
-
-            if ((r > radKinner) && (r < radKron)) {
-                SumInner += pDiff;
-                nInner ++;
-            }
-            if ((r > radKron)  && (r < radKouter)) {
-                SumOuter += pDiff;
-                nOuter ++;
-            }
-        }
-    }
-    // *** should I rescale these fluxes by pi R^2 / nNpix?
-    source->moments->KronCore    = SumCore       * M_PI * PS_SQR(sigma) / nCorePix;
-    source->moments->KronCoreErr = sqrt(VarCore) * M_PI * PS_SQR(sigma) / nCorePix;
-    source->moments->KronFlux    = Sum       * M_PI * PS_SQR(radKron) / nKronPix;
-    source->moments->KronFluxErr = sqrt(Var) * M_PI * PS_SQR(radKron) / nKronPix;
-    source->moments->KronFinner = SumInner * M_PI * (PS_SQR(radKron)   - PS_SQR(radKinner)) / nInner;
-    source->moments->KronFouter = SumOuter * M_PI * (PS_SQR(radKouter) -   PS_SQR(radKron)) / nOuter;
-
-    psTrace ("psModules.objects", 4, "Mrf: %f  KronFlux: %f  Mxx: %f  Mxy: %f  Myy: %f  Mxxx: %f  Mxxy: %f  Mxyy: %f  Myyy: %f  Mxxxx: %f  Mxxxy: %f  Mxxyy: %f  Mxyyy: %f  Mxyyy: %f\n",
-             source->moments->Mrf,   source->moments->KronFlux, 
-             source->moments->Mxx,   source->moments->Mxy,   source->moments->Myy,
-             source->moments->Mxxx,  source->moments->Mxxy,  source->moments->Mxyy,  source->moments->Myyy,
-             source->moments->Mxxxx, source->moments->Mxxxy, source->moments->Mxxyy, source->moments->Mxyyy, source->moments->Myyyy);
-
-    psTrace ("psModules.objects", 3, "peak %f %f (%f = %f) Mx: %f  My: %f  Sum: %f  Mxx: %f  Mxy: %f  Myy: %f  sky: %f  Npix: %d\n",
-             source->peak->xf, source->peak->yf, source->peak->rawFlux, sqrt(source->peak->detValue), source->moments->Mx,   source->moments->My, Sum, source->moments->Mxx,   source->moments->Mxy,   source->moments->Myy, sky, source->moments->nPixels);
-
-    return(true);
-}
-
-bool pmSourceMomentsGetCentroid(pmSource *source, float radius, float sigma, float minSN, psImageMaskType maskVal, float xGuess, float yGuess) { 
-
-    // First Pass: calculate the first moments (these are subtracted from the coordinates below)
-    // Sum = SUM (z - sky)
-    // X1  = SUM (x - xc)*(z - sky)
-    // .. etc
-
-    float sky = 0.0;
-
-    float peakPixel = -PS_MAX_F32;
-    psS32 numPixels = 0;
-    float Sum = 0.0;
-    float Var = 0.0;
-    float X1 = 0.0;
-    float Y1 = 0.0;
-    float R2 = PS_SQR(radius);
-    float minSN2 = PS_SQR(minSN);
-    float rsigma2 = 0.5 / PS_SQR(sigma);
-
-    float xPeak = xGuess - source->pixels->col0; // coord of peak in subimage
-    float yPeak = yGuess - source->pixels->row0; // coord of peak in subimage
-
-    // we are guaranteed to have a valid pixel and variance at this location (right? right?)
-    // float weightNorm = source->pixels->data.F32[yPeak][xPeak] / sqrt (source->variance->data.F32[yPeak][xPeak]);
-    // psAssert (isfinite(source->pixels->data.F32[yPeak][xPeak]), "peak must be on valid pixel");
-    // psAssert (isfinite(source->variance->data.F32[yPeak][xPeak]), "peak must be on valid pixel");
-    // psAssert (source->variance->data.F32[yPeak][xPeak] > 0, "peak must be on valid pixel");
-
-    // the moments [Sum(x*f) / Sum(f)] are calculated in pixel index values, and should
-    // not depend on the fractional pixel location of the source.  However, the aperture
-    // (radius) and the Gaussian window (sigma) depend subtly on the fractional pixel
-    // position of the expected centroid
-
-    for (psS32 row = 0; row < source->pixels->numRows ; row++) {
-
-        float yDiff = row + 0.5 - yPeak;
-        if (fabs(yDiff) > radius) continue;
-
-        float *vPix = source->pixels->data.F32[row];
-        float *vWgt = source->variance->data.F32[row];
-
-        psImageMaskType *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row];
-        // psImageMaskType *vMsk = (source->maskView == NULL) ? NULL : source->maskView->data.PS_TYPE_IMAGE_MASK_DATA[row];
-
-        for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) {
-            if (vMsk) {
-                if (*vMsk & maskVal) {
-                    vMsk++;
-                    continue;
-                }
-                vMsk++;
-            }
-            if (isnan(*vPix)) continue;
-
             float xDiff = col + 0.5 - xPeak;
             if (fabs(xDiff) > radius) continue;

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceOutputs.c

@@ -107 +107 @@
         }
         if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXY]) && isfinite(PAR[PM_PAR_SYY])) {
-            axes = pmPSF_ModelToAxes (PAR, 20.0);
+            axes = pmPSF_ModelToAxes (PAR, 20.0, model->type);
             outputs->psfMajor = axes.major;
             outputs->psfMinor = axes.minor;
@@ -178 +178 @@
     moments->KronCore    = source->moments ? source->moments->KronCore : NAN;
     moments->KronCoreErr = source->moments ? source->moments->KronCoreErr : NAN;
-
-    return true;
-}
+    moments->KronPSF    = source->moments ? source->moments->KronFluxPSF : NAN;
+    moments->KronPSFErr = source->moments ? source->moments->KronFluxPSFErr : NAN;
+
+    return true;
+}
+
+bool pmSourceLocalAstrometry (psSphere *ptSky, float *posAngle, float *pltScale, pmChip *chip, float xPos, float yPos) {
+
+    pmFPA *fpa = chip->parent;
+
+    if (!chip->toFPA) goto escape;
+    if (!fpa->toTPA) goto escape;
+    if (!fpa->toSky) goto escape;
+
+    // generate RA,DEC
+    psPlane ptCH, ptFP, ptTP_o, ptTP_x, ptTP_y;
+
+    // calculate the astrometry for the coordinate of interest
+    ptCH.x = xPos;
+    ptCH.y = yPos;
+    psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
+    psPlaneTransformApply (&ptTP_o, fpa->toTPA, &ptFP);
+    psDeproject (ptSky, &ptTP_o, fpa->toSky);
+
+    // calculate the astrometry for the coordinate + 1pix in X
+    ptCH.x = xPos + 1.0;
+    ptCH.y = yPos;
+    psPlaneTransformApply (&ptFP, chip->toFPA, &ptCH);
+    psPlaneTransformApply (&ptTP_x, fpa->toTPA, &ptFP);
+
+    // calculate the astrometry for the coordinate + 1pix in Y
+    ptCH.x = xPos;
+    ptCH.y = yPos + 1.0;
+    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
+
+    float dTPx_dCHx = fpa->toSky->Xs * (ptTP_x.x - ptTP_o.x);
+    float dTPy_dCHx = fpa->toSky->Ys * (ptTP_x.y - ptTP_o.y);
+
+    float dTPx_dCHy = fpa->toSky->Xs * (ptTP_y.x - ptTP_o.x);
+    float dTPy_dCHy = fpa->toSky->Ys * (ptTP_y.y - ptTP_o.y);
+
+    float pltScale_x = hypot(dTPx_dCHx, dTPy_dCHx);
+    float pltScale_y = hypot(dTPx_dCHy, dTPy_dCHy);
+    *pltScale = 0.5*(pltScale_x + pltScale_y);
+
+    float posAngle_x = atan2 (+dTPy_dCHx, +dTPx_dCHx);
+    float posAngle_y = atan2 (-dTPy_dCHy, +dTPx_dCHy);
+    *posAngle = 0.5*(posAngle_x + posAngle_y);
+
+    return true;
+
+escape:
+    // no astrometry calibration, give up
+    ptSky->r = NAN;
+    ptSky->d = NAN;
+    *posAngle = NAN;
+    *pltScale = NAN;
+
+    return false;
+}
+

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourceOutputs.h

@@ -52 +52 @@
     float KronCore;
     float KronCoreErr;
+    float KronPSF;
+    float KronPSFErr;
 } pmSourceOutputsMoments;
 

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourcePhotometry.c

@@ -56 +56 @@
 static psImageMaskType maskBurntool = 0;
 static psImageMaskType maskConvPoor = 0;
+static psImageMaskType maskGhost    = 0;
+static psImageMaskType maskGlint    = 0;
 
 bool pmSourceMagnitudesInit (pmConfig *config, psMetadata *recipe)
@@ -68 +70 @@
         maskBurntool = pmConfigMaskGet("BURNTOOL", config);
         maskConvPoor = pmConfigMaskGet("CONV.POOR", config);
+        maskGhost    = pmConfigMaskGet("GHOST", config);
+        maskGlint    = pmConfigMaskGet("GHOST", config);
         maskSuspect  = maskSpike | maskStarCore | maskBurntool | maskConvPoor;
     }
@@ -94 +98 @@
 {
     PS_ASSERT_PTR_NON_NULL(source, false);
-    PS_ASSERT_PTR_NON_NULL(psf, false);
+    // PS_ASSERT_PTR_NON_NULL(psf, false);
 
     int status = false;
@@ -533 +537 @@
     }
 
+    // Check that if the peak is on/off a ghost, glint, or diffraction spike.  In regular IPP
+    // processing, these values are only set in the image mask after the 'camera' stage
+
+    int xChip = source->peak->x;
+    int yChip = source->peak->y;
+
+    // need to access the parent if we are looking at a subimage (likely)
+    psImage *chipImage = (source->pixels == NULL) ? source->pixels : (psImage *) source->pixels->parent;
+
+    bool onChip = true;
+    onChip &= (xChip >= 0);
+    onChip &= (xChip < chipImage->numCols);
+    onChip &= (yChip >= 0);
+    onChip &= (yChip < chipImage->numRows);
+    if (!onChip) {
+        // if the source is off the edge of the chip, raise a different bit?
+        source->mode |= PM_SOURCE_MODE_OFF_CHIP;
+    } else {
+        int xMask = xChip - mask->col0;
+        int yMask = yChip - mask->row0;
+        psImageMaskType maskValue = mask->data.PS_TYPE_IMAGE_MASK_DATA[yMask][xMask];
+        if (maskValue & maskGhost) {
+            source->mode |= PM_SOURCE_MODE_ON_GHOST;
+        }
+        pmSourceMode PM_SOURCE_MODE_ON_GLINT = PM_SOURCE_MODE_ON_GHOST;
+        if (maskValue & maskGlint) {
+            source->mode |= PM_SOURCE_MODE_ON_GLINT;
+        }
+        if (maskValue & maskSpike) {
+            source->mode |= PM_SOURCE_MODE_ON_SPIKE;
+        }
+    }
     return (true);
 }

branches/meh_branches/ppstack_test/psModules/src/objects/pmSourcePlotPSFModel.c

@@ -145 +145 @@
         // force the axis ratio to be < 20.0
         psEllipseAxes axes_mnt = psEllipseMomentsToAxes (moments, 20.0);
-        psEllipseAxes axes_psf = pmPSF_ModelToAxes (PAR, 20.0);
+        psEllipseAxes axes_psf = pmPSF_ModelToAxes (PAR, 20.0, model->type);
 
         // moments major axis

@@ -5 +5 @@
 *.la
 *.lo
+pmSourceIO_CMF_PS1_V1.c
+pmSourceIO_CMF_PS1_V2.c
+pmSourceIO_CMF_PS1_V3.c
+pmSourceIO_CMF_PS1_V4.c
+pmSourceIO_CMF_PS1_V3.v1.c
+pmSourceIO_CMF_PS1_V1.v1.c
+pmSourceIO_CMF_PS1_V2.v1.c
+