Index: /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCM_MinimizeChisq.c
===================================================================
--- /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCM_MinimizeChisq.c	(revision 36280)
+++ /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCM_MinimizeChisq.c	(revision 36281)
@@ -473,12 +473,15 @@
 # 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);
-	
-	// hard-wire this for now?
-	psImageSmoothCache_F32 (pcm->modelConvFlux, pcm->smdata1);
-	psImageSmoothCache_F32 (pcm->modelConvFlux, pcm->smdata2);
+
+	if (USE_1D_CACHE) {
+	    // 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);
+	    psImageSmoothCache_F32 (pcm->modelConvFlux, pcm->smdata);
+	} else {
+	    pcm->modelConvFlux = psImageCopy (pcm->modelConvFlux, pcm->modelFlux, pcm->modelFlux->type.type);
+	    psImageSmooth2dCache_F32 (pcm->modelConvFlux, pcm->smdata2d);
+	}
     } else {
 	psImageConvolveKernel (pcm->modelConvFlux, pcm->modelFlux, NULL, 0, pcm->psfFFT);
@@ -495,10 +498,14 @@
 # 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);
-	    psImageSmoothCache_F32 (dmodelConv, pcm->smdata1);
-	    psImageSmoothCache_F32 (dmodelConv, pcm->smdata2);
+	    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
+		dmodelConv = psImageCopy (dmodelConv, dmodel, dmodel->type.type);
+		psImageSmoothCache_F32 (dmodelConv, pcm->smdata);
+	    } else {
+		dmodelConv = psImageCopy (dmodelConv, dmodel, dmodel->type.type);
+		psImageSmooth2dCache_F32 (dmodelConv, pcm->smdata2d);
+	    }
 	} else {
 	    psImageConvolveKernel (dmodelConv, dmodel, NULL, 0, pcm->psfFFT);
@@ -516,10 +523,14 @@
 
 	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);
-	    psImageSmoothCache_F32 (dmodelConv, pcm->smdata1);
-	    psImageSmoothCache_F32 (dmodelConv, pcm->smdata2);
+	    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
+		dmodelConv = psImageCopy (dmodelConv, dmodel, dmodel->type.type);
+		psImageSmoothCache_F32 (dmodelConv, pcm->smdata);
+	    } else {
+		dmodelConv = psImageCopy (dmodelConv, dmodel, dmodel->type.type);
+		psImageSmooth2dCache_F32 (dmodelConv, pcm->smdata2d);
+	    }
 	} else {
 	    psImageConvolveFFT (dmodelConv, dmodel, NULL, 0, pcm->psf);
Index: /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCMdata.c
===================================================================
--- /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCMdata.c	(revision 36280)
+++ /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCMdata.c	(revision 36281)
@@ -43,5 +43,5 @@
 
 # define USE_DELTA_PSF 0
-# define USE_1D_GAUSS 1
+# define KERNEL_NSIGMA 3.0
 
 static void pmPCMdataFree (pmPCMdata *pcm) {
@@ -104,5 +104,5 @@
     // convolution with a Gaussian approximation to the kernel
     pcm->use1Dgauss = false;
-    pcm->nsigma = 5.0; 
+    pcm->nsigma = KERNEL_NSIGMA; 
     pcm->sigma = 1.0; // this should be set to something sensible when the psf is known
 
@@ -288,6 +288,5 @@
 }
 
-// set 2 gaussians (extend to more if interesting)
-psImageSmoothCacheData *psImageSmoothCacheSetKernel (float *sigma1, float *sigma2, psImage *flux, pmModel *modelPSF) {
+psImageSmoothCacheData *psImageSmoothCacheSetKernel (float *sigma, float *kappa, float nsigma, psImage *flux, pmModel *modelPSF) {
 
     psAssert (modelPSF, "psf model must be defined");
@@ -298,7 +297,6 @@
     pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
     
-    float nsigma = 5.0;
-    *sigma1 = NAN;
-    *sigma2 = NAN;
+    *sigma = NAN;
+    *kappa = NAN;
 
     // XXX need to do this more carefully
@@ -306,6 +304,5 @@
 	float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
 	float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
-	*sigma1 = 0.50 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
-	*sigma2 = 0.25 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
+	*sigma = 0.50 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
     }
     if (modelPSF->type == modelType_PS1_V1) {
@@ -323,4 +320,41 @@
     if (modelPSF->type == modelType_PS1_V1) {
 	psImageSmoothCacheKernel_PS1_V1 (smdata, *sigma, *kappa);
+    }
+
+    return smdata;
+}
+
+psImageSmooth2dCacheData *psImageSmooth2dCacheSetKernel (float *sigma, float *kappa, float nsigma, psImage *flux, pmModel *modelPSF) {
+
+    psAssert (modelPSF, "psf model must be defined");
+    
+    psEllipseAxes axes;
+    bool useReff = pmModelUseReff (modelPSF->type);
+    psF32 *PAR = modelPSF->params->data.F32;
+    pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
+    
+    *sigma = NAN;
+    *kappa = NAN;
+
+    // XXX need to do this more carefully
+    if (modelPSF->type == modelType_GAUSS) {
+	float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
+	float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
+	*sigma = 0.50 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
+    }
+    if (modelPSF->type == modelType_PS1_V1) {
+	*sigma = 0.5 * (axes.major + axes.minor);
+	*kappa = PAR[PM_PAR_7];
+    }
+    psAssert (isfinite(*sigma), "invalid model type");
+
+    // psImageSmoothCacheAlloc generates a structure but does not assign the smoothing vector
+    psImageSmooth2dCacheData *smdata = psImageSmooth2dCacheAlloc (nsigma);
+
+    if (modelPSF->type == modelType_GAUSS) {
+	// psImageSmooth2dCacheKernel_Gauss (smdata, *sigma);
+    }
+    if (modelPSF->type == modelType_PS1_V1) {
+	psImageSmooth2dCacheKernel_PS1_V1 (smdata, *sigma, *kappa);
     }
 
@@ -384,5 +418,9 @@
 
     pcm->use1Dgauss = true;
-    pcm->smdata = psImageSmoothCacheSetKernel (&pcm->sigma, &pcm->kappa, source->pixels, source->modelPSF);
+    if (USE_1D_CACHE) {
+	pcm->smdata = psImageSmoothCacheSetKernel (&pcm->sigma, &pcm->kappa, pcm->nsigma, source->pixels, source->modelPSF);
+    } else {
+	pcm->smdata2d = psImageSmooth2dCacheSetKernel (&pcm->sigma, &pcm->kappa, pcm->nsigma, source->pixels, source->modelPSF);
+    }
 
 # else
@@ -467,13 +505,26 @@
 
 	// If we have changed the window, we need to redefine the smoothing target vectors (but pcm->sigma,kappa,nsigma remain)
-	psFree(pcm->smdata);
-	pcm->smdata = psImageSmoothCacheAlloc (source->pixels, pcm->sigma, pcm->nsigma);
-
-	pmModel *modelPSF = source->modelPSF;
-	if (modelPSF->type == modelType_GAUSS) {
-	    psImageSmoothCacheKernel_Gauss (pcm->smdata, pcm->sigma);
-	}
-	if (modelPSF->type == modelType_PS1_V1) {
-	    psImageSmoothCacheKernel_PS1_V1 (pcm->smdata, pcm->sigma, pcm->kappa);
+	if (USE_1D_CACHE) {
+	    psFree(pcm->smdata);
+	    pcm->smdata = psImageSmoothCacheAlloc (source->pixels, pcm->sigma, pcm->nsigma);
+
+	    pmModel *modelPSF = source->modelPSF;
+	    if (modelPSF->type == modelType_GAUSS) {
+		psImageSmoothCacheKernel_Gauss (pcm->smdata, pcm->sigma);
+	    }
+	    if (modelPSF->type == modelType_PS1_V1) {
+		psImageSmoothCacheKernel_PS1_V1 (pcm->smdata, pcm->sigma, pcm->kappa);
+	    }
+	} else {
+	    psFree(pcm->smdata2d);
+	    pcm->smdata2d = psImageSmooth2dCacheAlloc (pcm->nsigma);
+
+	    pmModel *modelPSF = source->modelPSF;
+	    if (modelPSF->type == modelType_GAUSS) {
+		// psImageSmooth2dCacheKernel_Gauss (pcm->smdata2d, pcm->sigma);
+	    }
+	    if (modelPSF->type == modelType_PS1_V1) {
+		psImageSmooth2dCacheKernel_PS1_V1 (pcm->smdata2d, pcm->sigma, pcm->kappa);
+	    }
 	}
     }
@@ -503,9 +554,14 @@
 	float sigma = NAN;
 	float kappa = NAN;
-	psImageSmoothCacheData *smdata = psImageSmoothCacheSetKernel (&sigma, &kappa, source->modelFlux, source->modelPSF);
-
-	psImageSmoothCache_F32 (source->modelFlux, smdata);
-	psFree (smdata);
-
+
+	if (USE_1D_CACHE) {
+	    psImageSmoothCacheData *smdata = psImageSmoothCacheSetKernel (&sigma, &kappa, KERNEL_NSIGMA, source->modelFlux, source->modelPSF);
+	    psImageSmoothCache_F32 (source->modelFlux, smdata);
+	    psFree (smdata);
+	} else {
+	    psImageSmooth2dCacheData *smdata = psImageSmooth2dCacheSetKernel (&sigma, &kappa, KERNEL_NSIGMA, source->modelFlux, source->modelPSF);
+	    psImageSmooth2dCache_F32 (source->modelFlux, smdata);
+	    psFree (smdata);
+	}
 	// old call: psImageSmooth (source->modelFlux, sigma, nsigma);
     } else {
@@ -544,9 +600,14 @@
 	float sigma = NAN;
 	float kappa = NAN;
-	psImageSmoothCacheData *smdata = psImageSmoothCacheSetKernel (&sigma, &kappa, source->modelFlux, source->modelPSF);
-
-	psImageSmoothCache_F32 (source->modelFlux, smdata);
-	psFree (smdata);
-
+
+	if (USE_1D_CACHE) {
+	    psImageSmoothCacheData *smdata = psImageSmoothCacheSetKernel (&sigma, &kappa, KERNEL_NSIGMA, source->modelFlux, source->modelPSF);
+	    psImageSmoothCache_F32 (source->modelFlux, smdata);
+	    psFree (smdata);
+	} else {
+	    psImageSmooth2dCacheData *smdata = psImageSmooth2dCacheSetKernel (&sigma, &kappa, KERNEL_NSIGMA, source->modelFlux, source->modelPSF);
+	    psImageSmooth2dCache_F32 (source->modelFlux, smdata);
+	    psFree (smdata);
+	}
 	// old call: psImageSmooth (source->modelFlux, sigma, nsigma);
     } else {
Index: /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCMdata.h
===================================================================
--- /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCMdata.h	(revision 36280)
+++ /branches/eam_branches/ipp-20130904/psModules/src/objects/pmPCMdata.h	(revision 36281)
@@ -14,4 +14,8 @@
 /// @addtogroup Objects Object Detection / Analysis Functions
 /// @{
+
+// XXX this is basically for testing -- when I am happy with the convolution process, I'll strip this out
+# define USE_1D_CACHE 0
+# define USE_1D_GAUSS 1
 
 /** pmPCMdata : PSF Convolved Model data storage structure
@@ -40,4 +44,5 @@
     bool use1Dgauss;
     float kappa;
+    float sigma;
     float nsigma;
 
Index: /branches/eam_branches/ipp-20130904/psModules/src/objects/pmSourceIO.c
===================================================================
--- /branches/eam_branches/ipp-20130904/psModules/src/objects/pmSourceIO.c	(revision 36280)
+++ /branches/eam_branches/ipp-20130904/psModules/src/objects/pmSourceIO.c	(revision 36281)
@@ -646,4 +646,11 @@
 
       case PM_FPA_FILE_CFF: {
+        // determine the output table format
+        psMetadata *recipe = psMetadataLookupMetadata(&status, config->recipes, "PSPHOT");
+        if (!status) {
+	    psError(PS_ERR_UNKNOWN, true, "missing recipe PSPHOT in config data");
+	    return false;
+        }
+
         hdu = pmFPAviewThisHDU (view, fpa);
         pmConfigConformHeader(hdu->header, file->format);