Index: trunk/psphot/src/psphotModelWithPSF.c
===================================================================
--- trunk/psphot/src/psphotModelWithPSF.c	(revision 21183)
+++ trunk/psphot/src/psphotModelWithPSF.c	(revision 21366)
@@ -20,5 +20,5 @@
         paramMask = constraint->paramMask;
         if (paramMask != NULL) {
-	  PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
+          PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false);
             PS_ASSERT_VECTORS_SIZE_EQUAL(params, paramMask, false);
         }
@@ -42,7 +42,7 @@
     // Alpha & Beta only contain elements to represent the unmasked parameters
     if (!psMinLM_AllocAB (&Alpha, &Beta, params, paramMask)) {
-	psAbort ("programming error: no unmasked parameters to be fit\n");
-    }
-    
+        psAbort ("programming error: no unmasked parameters to be fit\n");
+    }
+
     // allocate internal arrays (current vs Guess)
     psImage *alpha   = psImageAlloc(Alpha->numCols, Alpha->numRows, PS_TYPE_F32);
@@ -127,7 +127,7 @@
             lambda *= 0.25;
 
-	    // save the new convolved model image
-	    psFree (source->modelFlux);
-	    source->modelFlux = pmPCMDataSaveImage(pcm);
+            // save the new convolved model image
+            psFree (source->modelFlux);
+            source->modelFlux = pmPCMDataSaveImage(pcm);
         } else {
             lambda *= 10.0;
@@ -142,18 +142,18 @@
             psTrace ("psphot", 5, "failure to calculate covariance matrix\n");
         }
-	// set covar values which are not masked
-	psImageInit (covar, 0.0);
-	for (int j = 0, J = 0; j < params->n; j++) {
-	    if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
-		covar->data.F32[j][j] = 1.0;
-		continue;
-	    }
-	    for (int k = 0, K = 0; k < params->n; k++) {
-		if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
-		covar->data.F32[j][k] = Alpha->data.F32[J][K];
-		K++;
-	    }
-	    J++;
-	}
+        // set covar values which are not masked
+        psImageInit (covar, 0.0);
+        for (int j = 0, J = 0; j < params->n; j++) {
+            if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
+                covar->data.F32[j][j] = 1.0;
+                continue;
+            }
+            for (int k = 0, K = 0; k < params->n; k++) {
+                if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
+                covar->data.F32[j][k] = Alpha->data.F32[J][K];
+                K++;
+            }
+            J++;
+        }
     }
 
@@ -192,5 +192,5 @@
     PS_ASSERT_PTR_NON_NULL(source, NAN);
     PS_ASSERT_IMAGE_NON_NULL(source->pixels, NAN);
-    PS_ASSERT_IMAGE_NON_NULL(source->weight, NAN);
+    PS_ASSERT_IMAGE_NON_NULL(source->variance, NAN);
     PS_ASSERT_IMAGE_NON_NULL(source->maskObj, NAN);
 
@@ -210,6 +210,6 @@
     psImageInit (pcm->model, 0.0);
     for (int n = 0; n < params->n; n++) {
-	if (!pcm->dmodels->data[n]) continue;
-	psImageInit (pcm->dmodels->data[n], 0.0);
+        if (!pcm->dmodels->data[n]) continue;
+        psImageInit (pcm->dmodels->data[n], 0.0);
     }
 
@@ -218,24 +218,24 @@
         for (psS32 j = 0; j < source->pixels->numCols; j++) {
 
-	    // XXX can we skip some of the data points where the model
-	    // is not going to be fitted??
+            // XXX can we skip some of the data points where the model
+            // is not going to be fitted??
 
             // skip masked points
-	    // XXX probably should not skipped masked points: 
-	    // XXX skip if convolution of unmasked pixels will not see this pixel
+            // XXX probably should not skipped masked points:
+            // XXX skip if convolution of unmasked pixels will not see this pixel
             // if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
-	    // continue;
-	    // }
-
-            // skip zero-weight points
-	    // XXX why is this not masked?
-            // if (source->weight->data.F32[i][j] == 0) {
-	    // continue;
-	    // }
+            // continue;
+            // }
+
+            // skip zero-variance points
+            // XXX why is this not masked?
+            // if (source->variance->data.F32[i][j] == 0) {
+            // continue;
+            // }
             // skip nan value points
-	    // XXX why is this not masked?
+            // XXX why is this not masked?
             // if (!isfinite(source->pixels->data.F32[i][j])) {
-	    // continue;
-	    // }
+            // continue;
+            // }
 
             // Convert i/j to image space:
@@ -243,11 +243,11 @@
             coord->data.F32[1] = (psF32) (i + source->pixels->row0);
 
-	    pcm->model->data.F32[i][j] = func (deriv, params, coord);
-
-	    for (int n = 0; n < params->n; n++) {
-		if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
-		psImage *dmodel = pcm->dmodels->data[n];
-		dmodel->data.F32[i][j] = deriv->data.F32[n];
-	    }
+            pcm->model->data.F32[i][j] = func (deriv, params, coord);
+
+            for (int n = 0; n < params->n; n++) {
+                if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
+                psImage *dmodel = pcm->dmodels->data[n];
+                dmodel->data.F32[i][j] = deriv->data.F32[n];
+            }
         }
     }
@@ -258,12 +258,12 @@
     psImageConvolveDirect (pcm->modelConv, pcm->model, psf);
     for (int n = 0; n < pcm->dmodels->n; n++) {
-	if (pcm->dmodels->data[n] == NULL) continue;
-	psImage *dmodel = pcm->dmodels->data[n];
-	psImage *dmodelConv = pcm->dmodelsConv->data[n];
-	psImageConvolveDirect (dmodelConv, dmodel, psf);
+        if (pcm->dmodels->data[n] == NULL) continue;
+        psImage *dmodel = pcm->dmodels->data[n];
+        psImage *dmodelConv = pcm->dmodelsConv->data[n];
+        psImageConvolveDirect (dmodelConv, dmodel, psf);
     }
 
     // XXX TEST : SAVE IMAGES
-# if (SAVE_IMAGES) 
+# if (SAVE_IMAGES)
     psphotSaveImage (NULL, psf->image, "psf.fits");
     psphotSaveImage (NULL, pcm->model, "model.fits");
@@ -271,8 +271,8 @@
     psphotSaveImage (NULL, source->pixels, "obj.fits");
     psphotSaveImage (NULL, source->maskObj, "mask.fits");
-    psphotSaveImage (NULL, source->weight, "weight.fits");
+    psphotSaveImage (NULL, source->variance, "variance.fits");
 # endif
 
-    // 2 *** accumulate alpha & beta 
+    // 2 *** accumulate alpha & beta
 
     // zero alpha and beta for summing below
@@ -283,11 +283,11 @@
     for (psS32 i = 0; i < source->pixels->numRows; i++) {
         for (psS32 j = 0; j < source->pixels->numCols; j++) {
-	    // XXX are we doing the right thing with the mask?
+            // XXX are we doing the right thing with the mask?
             // skip masked points
             if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) {
                 continue;
             }
-            // skip zero-weight points
-            if (source->weight->data.F32[i][j] == 0) {
+            // skip zero-variance points
+            if (source->variance->data.F32[i][j] == 0) {
                 continue;
             }
@@ -297,28 +297,28 @@
             }
 
-	    float ymodel  = pcm->modelConv->data.F32[i][j];
-	    float yweight = 1.0 / source->weight->data.F32[i][j];
-	    float delta = ymodel - source->pixels->data.F32[i][j];
-
-	    chisq += PS_SQR(delta) * yweight;
-
-	    if (isnan(delta)) psAbort("nan in delta");
-	    if (isnan(chisq)) psAbort("nan in chisq");
-
-	    // alpha & beta only contain unmasked elements 
-	    for (int n1 = 0, N1 = 0; n1 < params->n; n1++) {
-		if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n1])) continue;
-		psImage *dmodel = pcm->dmodelsConv->data[n1];
-		float weight = dmodel->data.F32[i][j] * yweight;
-		for (int n2 = 0, N2 = 0; n2 <= n1; n2++) {
-		    if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n2])) continue;
-		    dmodel = pcm->dmodelsConv->data[n2];
-		    alpha->data.F32[N1][N2] += weight * dmodel->data.F32[i][j];
-		    N2++;
-		}
-		beta->data.F32[N1] += weight * delta;
-		N1++;
-	    }
-	}
+            float ymodel  = pcm->modelConv->data.F32[i][j];
+            float yweight = 1.0 / source->variance->data.F32[i][j];
+            float delta = ymodel - source->pixels->data.F32[i][j];
+
+            chisq += PS_SQR(delta) * yweight;
+
+            if (isnan(delta)) psAbort("nan in delta");
+            if (isnan(chisq)) psAbort("nan in chisq");
+
+            // alpha & beta only contain unmasked elements
+            for (int n1 = 0, N1 = 0; n1 < params->n; n1++) {
+                if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n1])) continue;
+                psImage *dmodel = pcm->dmodelsConv->data[n1];
+                float weight = dmodel->data.F32[i][j] * yweight;
+                for (int n2 = 0, N2 = 0; n2 <= n1; n2++) {
+                    if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n2])) continue;
+                    dmodel = pcm->dmodelsConv->data[n2];
+                    alpha->data.F32[N1][N2] += weight * dmodel->data.F32[i][j];
+                    N2++;
+                }
+                beta->data.F32[N1] += weight * delta;
+                N1++;
+            }
+        }
     }
 
@@ -356,7 +356,7 @@
     pcm->dmodels = psArrayAlloc (params->n);
     for (psS32 n = 0; n < params->n; n++) {
-	pcm->dmodels->data[n] = NULL;
-	if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
-	pcm->dmodels->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
+        pcm->dmodels->data[n] = NULL;
+        if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
+        pcm->dmodels->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
     }
 
@@ -365,7 +365,7 @@
     pcm->dmodelsConv = psArrayAlloc (params->n);
     for (psS32 n = 0; n < params->n; n++) {
-	pcm->dmodelsConv->data[n] = NULL;
-	if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
-	pcm->dmodelsConv->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
+        pcm->dmodelsConv->data[n] = NULL;
+        if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; }
+        pcm->dmodelsConv->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32);
     }
 
@@ -376,5 +376,5 @@
 
     psImage *model = psImageCopy (NULL, pcm->modelConv, PS_TYPE_F32);
-   
+
     return model;
 }
@@ -383,11 +383,11 @@
  *
  * we have a function func(param; value)
- 
+
  * basic LMM:
- 
+
  - fill in the data (x, y)
- 
+
  chisq = SetABX (alpha, beta, params, paramMask, x, y, dy, func)
- 
+
  while () {
  GuessABP (Alpha, Beta, Params, alpha, beta, params, paramMask, checkLimits, lambda)
@@ -396,6 +396,6 @@
  convergence tests...
  }
- 
- 
+
+
 
  ** GuessABP: