Index: /trunk/psphot/src/models/pmModel_GAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_GAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_GAUSS.c	(revision 9529)
@@ -145,6 +145,6 @@
     status = true;
     status &= (dP < 0.5);
-    status &= (PAR[PM_PAR_FLUX] > 0);
-    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
+    status &= (PAR[PM_PAR_I0] > 0);
+    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
 
     if (status) return true;
Index: /trunk/psphot/src/models/pmModel_PGAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_PGAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_PGAUSS.c	(revision 9529)
@@ -23,9 +23,9 @@
     psF32 t  = 1 + z + z*z/2.0;
     psF32 r  = 1.0 / (t + z*z*z/6.0); /* exp (-Z) */
-    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
+    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
 
     if (deriv != NULL) {
-        // note difference from a pure gaussian: q = PAR[PM_PAR_FLUX]*r
-        psF32 q = PAR[PM_PAR_FLUX]*r*r*t;
+        // note difference from a pure gaussian: q = PAR[PM_PAR_I0]*r
+        psF32 q = PAR[PM_PAR_I0]*r*r*t;
         deriv->data.F32[0] = +1.0;
         deriv->data.F32[1] = +r;
@@ -92,5 +92,5 @@
     norm *= 0.01;
     
-    psF64 Flux = params->data.F32[PM_PAR_FLUX] * Area * norm;
+    psF64 Flux = params->data.F32[PM_PAR_I0] * Area * norm;
 
     return(Flux);
@@ -160,6 +160,6 @@
     status = true;
     status &= (dP < 0.5);
-    status &= (PAR[PM_PAR_FLUX] > 0);
-    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
+    status &= (PAR[PM_PAR_I0] > 0);
+    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
 
     if (status) return true;
Index: /trunk/psphot/src/models/pmModel_QGAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_QGAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_QGAUSS.c	(revision 9529)
@@ -33,9 +33,9 @@
 
     psF32 r  = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, QG_S1));
-    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
+    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
 
     if (deriv != NULL) {
         // note difference from a pure gaussian: q = params->data.F32[1]*r
-        psF32 t = PAR[PM_PAR_FLUX]*r*r;
+        psF32 t = PAR[PM_PAR_I0]*r*r;
 	psF32 q = t*(PAR[PM_PAR_7] + QG_S1*pow(z, dQG_S1));
 
@@ -125,5 +125,5 @@
     norm *= 0.01;
     
-    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
+    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
 
     return(Flux);
@@ -138,11 +138,11 @@
 
     if (flux <= 0) return (1.0);
-    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
-    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
+    if (PAR[PM_PAR_I0] <= 0) return (1.0);
+    if (flux >= PAR[PM_PAR_I0]) return (1.0);
 
     // if Sx == Sy, sigma = Sx == Sy
     psF64 sigma = hypot (1.0 / PAR[PM_PAR_SXX], 1.0 / PAR[PM_PAR_SYY]) / sqrt(2.0);
     psF64 dz = 1.0 / (2.0 * sigma*sigma);
-    psF64 limit = flux / PAR[PM_PAR_FLUX];
+    psF64 limit = flux / PAR[PM_PAR_I0];
 
     // we can do this much better with intelligent choices here
@@ -190,6 +190,6 @@
     status = true;
     status &= (dP < 0.5);
-    status &= (PAR[PM_PAR_FLUX] > 0);
-    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
+    status &= (PAR[PM_PAR_I0] > 0);
+    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
 
     if (status) return true;
Index: /trunk/psphot/src/models/pmModel_RGAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_RGAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_RGAUSS.c	(revision 9529)
@@ -30,9 +30,9 @@
     psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
     psF32 r  = 1.0 / (1 + z + z*p);
-    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
+    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
 
     if (deriv != NULL) {
         // note difference from a pure gaussian: q = params->data.F32[1]*r
-        psF32 t = PAR[PM_PAR_FLUX]*r*r;
+        psF32 t = PAR[PM_PAR_I0]*r*r;
 	psF32 q = t*(1 + PAR[PM_PAR_7]*p);
 
@@ -87,11 +87,11 @@
 
     if (flux <= 0) return (1.0);
-    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
-    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
+    if (PAR[PM_PAR_I0] <= 0) return (1.0);
+    if (flux >= PAR[PM_PAR_I0]) return (1.0);
 
     // if Sx == Sy, sigma = Sx == Sy
     psF64 sigma = hypot (1.0 / PAR[PM_PAR_SXX], 1.0 / PAR[PM_PAR_SYY]) / sqrt(2.0);
     psF64 dz = 1.0 / (2.0 * sigma*sigma);
-    psF64 limit = flux / PAR[PM_PAR_FLUX];
+    psF64 limit = flux / PAR[PM_PAR_I0];
 
     // we can do this much better with intelligent choices here
Index: /trunk/psphot/src/models/pmModel_SGAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_SGAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_SGAUSS.c	(revision 9529)
@@ -37,9 +37,9 @@
     psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
     psF32 r  = 1.0 / (1 + z*p + pr*pr3);
-    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
+    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
 
     if (deriv != NULL) {
         // note difference from a pure gaussian: q = params->data.F32[1]*r
-        psF32 t = PAR[PM_PAR_FLUX]*r*r;
+        psF32 t = PAR[PM_PAR_I0]*r*r;
 	psF32 q = t*(PAR[PM_PAR_7]*p + 4*PAR[PM_PAR_8]*pr3);
 
@@ -245,5 +245,5 @@
     norm *= 0.01;
     
-    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
+    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
 
     return(Flux);
@@ -262,6 +262,6 @@
 
     if (flux <= 0) return (1.0);
-    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
-    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
+    if (PAR[PM_PAR_I0] <= 0) return (1.0);
+    if (flux >= PAR[PM_PAR_I0]) return (1.0);
 
     // convert Sx,Sy,Sxy to major/minor axes
@@ -272,5 +272,5 @@
     axes = EllipseShapeToAxes (shape);
     psF64 dr = 1.0 / axes.major;
-    psF64 limit = flux / PAR[PM_PAR_FLUX];
+    psF64 limit = flux / PAR[PM_PAR_I0];
 
     // XXX : we can do this faster with an intelligent starting choice
@@ -329,6 +329,6 @@
     status = true;
     status &= (dP < 0.5);
-    status &= (PAR[PM_PAR_FLUX] > 0);
-    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
+    status &= (PAR[PM_PAR_I0] > 0);
+    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
     status &= (fabs(PAR[PM_PAR_8]) < 0.5);
     status &= (dPAR[PM_PAR_8] < 0.1);
Index: /trunk/psphot/src/models/pmModel_TAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_TAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_TAUSS.c	(revision 9529)
@@ -155,6 +155,6 @@
     status = true;
     status &= (dP < 0.5);
-    status &= (PAR[PM_PAR_FLUX] > 0);
-    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
+    status &= (PAR[PM_PAR_I0] > 0);
+    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
 
     if (status)
Index: /trunk/psphot/src/models/pmModel_TGAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_TGAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_TGAUSS.c	(revision 9529)
@@ -35,8 +35,8 @@
 
     psF32 r  = 1.0 / (er + PAR[PM_PAR_7]*z + pow(z, TG_S));    // (1/R)
-    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
+    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
 
     if (deriv != NULL) {
-	psF32 t = PAR[PM_PAR_FLUX]*r*r;	// df/dR
+	psF32 t = PAR[PM_PAR_I0]*r*r;	// df/dR
 	psF32 q = t*(TRF*er + PAR[PM_PAR_7] + TG_S*pow(z, dTG_S));  // (df/dR)(dR/dz)
 
@@ -127,5 +127,5 @@
     norm *= 0.01;
     
-    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
+    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
 
     return(Flux);
@@ -140,11 +140,11 @@
 
     if (flux <= 0) return (1.0);
-    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
-    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
+    if (PAR[PM_PAR_I0] <= 0) return (1.0);
+    if (flux >= PAR[PM_PAR_I0]) return (1.0);
 
     // if Sx == Sy, sigma = Sx == Sy
     psF64 sigma = hypot (1.0 / PAR[PM_PAR_SXX], 1.0 / PAR[PM_PAR_SYY]) / sqrt(2.0);
     psF64 dz = 1.0 / (2.0 * sigma*sigma);
-    psF64 limit = flux / PAR[PM_PAR_FLUX];
+    psF64 limit = flux / PAR[PM_PAR_I0];
 
     // we can do this much better with intelligent choices here
@@ -193,6 +193,6 @@
     status = true;
     status &= (dP < 0.5);
-    status &= (PAR[PM_PAR_FLUX] > 0);
-    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
+    status &= (PAR[PM_PAR_I0] > 0);
+    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
 
     if (status) return true;
Index: /trunk/psphot/src/models/pmModel_ZGAUSS.c
===================================================================
--- /trunk/psphot/src/models/pmModel_ZGAUSS.c	(revision 9528)
+++ /trunk/psphot/src/models/pmModel_ZGAUSS.c	(revision 9529)
@@ -32,9 +32,9 @@
     psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
     psF32 r  = 1.0 / (1 + z*p + SQ(SQ(pr)));
-    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
+    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
 
     if (deriv != NULL) {
         // note difference from a pure gaussian: q = params->data.F32[1]*r
-        psF32 t = PAR[PM_PAR_FLUX]*r*r;
+        psF32 t = PAR[PM_PAR_I0]*r*r;
 	psF32 q = t*(PAR[PM_PAR_7]*p + 4*PAR8*pr*pr*pr);
 
@@ -72,5 +72,5 @@
     norm *= 0.01;
     
-    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
+    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
 
     return(Flux);
@@ -89,6 +89,6 @@
 
     if (flux <= 0) return (1.0);
-    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
-    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
+    if (PAR[PM_PAR_I0] <= 0) return (1.0);
+    if (flux >= PAR[PM_PAR_I0]) return (1.0);
 
     // convert Sx,Sy,Sxy to major/minor axes
@@ -99,5 +99,5 @@
     axes = EllipseShapeToAxes (shape);
     psF64 dr = 1.0 / axes.major;
-    psF64 limit = flux / PAR[PM_PAR_FLUX];
+    psF64 limit = flux / PAR[PM_PAR_I0];
 
     // XXX : we can do this faster with an intelligent starting choice
Index: /trunk/psphot/src/psphotApResid.c
===================================================================
--- /trunk/psphot/src/psphotApResid.c	(revision 9528)
+++ /trunk/psphot/src/psphotApResid.c	(revision 9529)
@@ -73,5 +73,5 @@
 	}
 
-	dMag->data.F64[Npsf] = model->dparams->data.F32[PM_PAR_FLUX] / model->params->data.F32[PM_PAR_FLUX];
+	dMag->data.F64[Npsf] = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
 
 	psVectorExtend (mask, 	 100, 1);
Index: /trunk/psphot/src/psphotEnsemblePSF.c
===================================================================
--- /trunk/psphot/src/psphotEnsemblePSF.c	(revision 9528)
+++ /trunk/psphot/src/psphotEnsemblePSF.c	(revision 9529)
@@ -119,5 +119,5 @@
 	// set model to unit peak, zero sky (we assume sky is subtracted)
 	model->params->data.F32[PM_PAR_SKY] = 0.0;
-	model->params->data.F32[PM_PAR_FLUX] = 1.0;
+	model->params->data.F32[PM_PAR_I0] = 1.0;
 
 	// fill in the model pixel values
@@ -200,6 +200,6 @@
 	    psAbort ("psphot", "ensemble source is nan");
 	}
-	Fi->modelPSF->params->data.F32[PM_PAR_FLUX] = norm->data.F32[i];
-	Fi->modelPSF->dparams->data.F32[PM_PAR_FLUX] = sqrt(sqrt(2) * norm->data.F32[i] / (sparse->Bfj->data.F32[i] * weight->data.F32[i]));
+	Fi->modelPSF->params->data.F32[PM_PAR_I0] = norm->data.F32[i];
+	Fi->modelPSF->dparams->data.F32[PM_PAR_I0] = sqrt(sqrt(2) * norm->data.F32[i] / (sparse->Bfj->data.F32[i] * weight->data.F32[i]));
 	// XXX EAM : this factor of sqrt(2) makes the errors consistent, but I don't understand it
 
Index: /trunk/psphot/src/psphotGrowthCurve.c
===================================================================
--- /trunk/psphot/src/psphotGrowthCurve.c	(revision 9528)
+++ /trunk/psphot/src/psphotGrowthCurve.c	(revision 9529)
@@ -24,5 +24,5 @@
     // create an object with center intensity of 1000
     modelRef->params->data.F32[PM_PAR_SKY] = 0;
-    modelRef->params->data.F32[PM_PAR_FLUX] = 1000;
+    modelRef->params->data.F32[PM_PAR_I0] = 1000;
     modelRef->params->data.F32[PM_PAR_XPOS] = xc;
     modelRef->params->data.F32[PM_PAR_YPOS] = yc;