Index: branches/eam_branches/20091201/psModules/src/imcombine/pmStackReject.c
===================================================================
--- branches/eam_branches/20091201/psModules/src/imcombine/pmStackReject.c	(revision 26761)
+++ branches/eam_branches/20091201/psModules/src/imcombine/pmStackReject.c	(revision 26769)
@@ -156,5 +156,5 @@
         psRegion *region = subRegions->data[i]; // Region of interest
         pmSubtractionKernels *kernels = subKernels->data[i]; // Kernel of interest
-        if (!pmSubtractionConvolve(NULL, convRO, NULL, inRO, NULL, stride, 0, 0, 1.0, 0.0,
+        if (!pmSubtractionConvolve(NULL, convRO, NULL, inRO, NULL, stride, 0, 0, 1.0, 0.0, 0.0,
                                    region, kernels, false, true)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to convolve mask image in region %d.", i);
Index: branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.c
===================================================================
--- branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.c	(revision 26761)
+++ branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.c	(revision 26769)
@@ -1153,5 +1153,5 @@
 bool pmSubtractionConvolve(pmReadout *out1, pmReadout *out2, const pmReadout *ro1, const pmReadout *ro2,
                            psImage *subMask, int stride, psImageMaskType maskBad, psImageMaskType maskPoor,
-                           float poorFrac, float kernelError, const psRegion *region,
+                           float poorFrac, float kernelError, float covarFrac, const psRegion *region,
                            const pmSubtractionKernels *kernels, bool doBG, bool useFFT)
 {
@@ -1195,4 +1195,6 @@
     PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(kernelError, 0.0, false);
     PS_ASSERT_FLOAT_LESS_THAN_OR_EQUAL(kernelError, 1.0, false);
+    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(covarFrac, 0.0, false);
+    PS_ASSERT_FLOAT_LESS_THAN(covarFrac, 1.0, false);
     if (region && psRegionIsNaN(*region)) {
         psString string = psRegionToString(*region);
@@ -1327,4 +1329,5 @@
     if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
         psKernel *kernel = pmSubtractionKernel(kernels, 0.0, 0.0, false); // Convolution kernel
+        psKernelTruncate(kernel, covarFrac);
         out1->covariance = psImageCovarianceCalculate(kernel, ro1->covariance);
         psFree(kernel);
@@ -1333,4 +1336,5 @@
         psKernel *kernel = pmSubtractionKernel(kernels, 0.0, 0.0,
                                                kernels->mode == PM_SUBTRACTION_MODE_DUAL); // Conv. kernel
+        psKernelTruncate(kernel, covarFrac);
         out2->covariance = psImageCovarianceCalculate(kernel, ro2->covariance);
         psFree(kernel);
Index: branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.h
===================================================================
--- branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.h	(revision 26761)
+++ branches/eam_branches/20091201/psModules/src/imcombine/pmSubtraction.h	(revision 26769)
@@ -113,5 +113,6 @@
                            psImageMaskType maskPoor, ///< Mask value to give poor pixels
                            float poorFrac, ///< Fraction for "poor"
-                           float sysError, ///< Relative systematic error
+                           float kernelError, ///< Relative systematic error in kernel
+                           float covarFrac,  ///< Truncation fraction for kernel before covariance calculation
                            const psRegion *region, ///< Region to convolve (or NULL)
                            const pmSubtractionKernels *kernels, ///< Kernel parameters
Index: branches/eam_branches/20091201/psModules/src/imcombine/pmSubtractionMatch.c
===================================================================
--- branches/eam_branches/20091201/psModules/src/imcombine/pmSubtractionMatch.c	(revision 26761)
+++ branches/eam_branches/20091201/psModules/src/imcombine/pmSubtractionMatch.c	(revision 26769)
@@ -121,4 +121,5 @@
                                   float skyError,           // Systematic error in images
                                   float kernelError, // Systematic error in kernel
+                                  float covarFrac,   // Fraction for kernel truncation before covariance
                                   psImageMaskType maskVal, // Value to mask for input
                                   psImageMaskType maskBad, // Mask for output bad pixels
@@ -181,4 +182,6 @@
         PS_ASSERT_FLOAT_LESS_THAN(kernelError, 1.0, false);
     }
+    PS_ASSERT_FLOAT_LARGER_THAN_OR_EQUAL(covarFrac, 0.0, false);
+    PS_ASSERT_FLOAT_LESS_THAN(covarFrac, 1.0, false);
     // Don't care about maskVal
     // Don't care about maskBad
@@ -246,5 +249,5 @@
 
 bool pmSubtractionMatchPrecalc(pmReadout *conv1, pmReadout *conv2, const pmReadout *ro1, const pmReadout *ro2,
-                               psMetadata *analysis, int stride, float kernelError,
+                               psMetadata *analysis, int stride, float kernelError, float covarFrac,
                                psImageMaskType maskVal, psImageMaskType maskBad, psImageMaskType maskPoor,
                                float poorFrac, float badFrac)
@@ -316,5 +319,5 @@
     }
 
-    if (!subtractionMatchCheck(conv1, conv2, ro1, ro2, stride, NAN, NAN, NAN, kernelError,
+    if (!subtractionMatchCheck(conv1, conv2, ro1, ro2, stride, NAN, NAN, NAN, kernelError, covarFrac,
                                maskVal, maskBad, maskPoor, poorFrac, badFrac, mode)) {
         psFree(kernels);
@@ -357,5 +360,5 @@
 
         if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, stride, maskBad, maskPoor, poorFrac,
-                                   kernelError, region, kernel, true, useFFT)) {
+                                   kernelError, covarFrac, region, kernel, true, useFFT)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to convolve image.");
             psFree(outAnalysis);
@@ -388,9 +391,9 @@
                         bool optimum, const psVector *optFWHMs, int optOrder, float optThreshold,
                         int iter, float rej, float normFrac, float sysError, float skyError,
-                        float kernelError, psImageMaskType maskVal, psImageMaskType maskBad,
+                        float kernelError, float covarFrac, psImageMaskType maskVal, psImageMaskType maskBad,
                         psImageMaskType maskPoor, float poorFrac, float badFrac, pmSubtractionMode subMode)
 {
     if (!subtractionMatchCheck(conv1, conv2, ro1, ro2, stride, normFrac, sysError, skyError, kernelError,
-                               maskVal, maskBad, maskPoor, poorFrac, badFrac, subMode)) {
+                               covarFrac, maskVal, maskBad, maskPoor, poorFrac, badFrac, subMode)) {
         return false;
     }
@@ -779,5 +782,5 @@
             psTrace("psModules.imcombine", 2, "Convolving...\n");
             if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, stride, maskBad, maskPoor, poorFrac,
-                                       kernelError, region, kernels, true, useFFT)) {
+                                       kernelError, covarFrac, region, kernels, true, useFFT)) {
                 psError(PS_ERR_UNKNOWN, false, "Unable to convolve image.");
                 goto MATCH_ERROR;
Index: branches/eam_branches/20091201/psModules/src/imcombine/pmSubtractionMatch.h
===================================================================
--- branches/eam_branches/20091201/psModules/src/imcombine/pmSubtractionMatch.h	(revision 26761)
+++ branches/eam_branches/20091201/psModules/src/imcombine/pmSubtractionMatch.h	(revision 26769)
@@ -43,4 +43,5 @@
                         float skyError, ///< Relative systematic error in images
                         float kernelError, ///< Relative systematic error in kernel
+                        float covarFrac,   ///< Fraction for kernel truncation before covariance calculation
                         psImageMaskType maskVal, ///< Value to mask for input
                         psImageMaskType maskBad, ///< Mask for output bad pixels
@@ -59,4 +60,5 @@
                                int stride, ///< Size for convolution patches
                                float kernelError, ///< Relative systematic error in kernel
+                               float covarFrac,   ///< Fraction for kernel truncation before covariance calc.
                                psImageMaskType maskVal, ///< Value to mask for input
                                psImageMaskType maskBad, ///< Mask for output bad pixels