Index: /branches/pap/psModules/src/imcombine/pmSubtraction.c
===================================================================
--- /branches/pap/psModules/src/imcombine/pmSubtraction.c	(revision 25902)
+++ /branches/pap/psModules/src/imcombine/pmSubtraction.c	(revision 25903)
@@ -29,4 +29,5 @@
 #define PIXEL_LIST_BUFFER 100           // Number of entries to add to pixel list at a time
 #define MIN_SAMPLE_STATS    7           // Minimum number to use sample statistics; otherwise use quartiles
+//#define USE_SYS_ERR                   // Use systematic error image?
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -36,5 +37,5 @@
 // Generate the kernel to apply to the variance from the normal kernel
 static psKernel *varianceKernel(psKernel *out, // Output kernel
-                                psKernel *normalKernel // Normal kernel
+                                const psKernel *normalKernel // Normal kernel
                                 )
 {
@@ -48,12 +49,8 @@
 
     // Take the square of the normal kernel
-    double sumNormal = 0.0, sumVariance = 0.0; // Sum of the normal and variance kernels
+    double sumVariance = 0.0; // Sum of the variance kernels
     for (int v = yMin; v <= yMax; v++) {
         for (int u = xMin; u <= xMax; u++) {
-            float value = normalKernel->kernel[v][u]; // Value of interest
-            float value2 = PS_SQR(value); // Value squared
-            sumNormal += value;
-            sumVariance += value2;
-            out->kernel[v][u] = value2;
+            sumVariance += out->kernel[v][u] = PS_SQR(normalKernel->kernel[v][u]);
         }
     }
@@ -432,4 +429,5 @@
 }
 
+#ifdef USE_SYS_ERR
 // Generate an image that can be used to track systematic errors
 static psImage *subtractionSysErrImage(const psImage *image, // Image from which to make sys err image
@@ -453,4 +451,5 @@
     return sys;
 }
+#endif
 
 // Convolve a stamp using an ISIS kernel basis function
@@ -1190,14 +1189,8 @@
         if (!out1->image) {
             out1->image = psImageAlloc(numCols, numRows, PS_TYPE_F32);
-            // XXX if (threaded) {
-            // XXX     psMutexInit(out1->image);
-            // XXX }
         }
         if (ro1->variance) {
             if (!out1->variance) {
                 out1->variance = psImageAlloc(numCols, numRows, PS_TYPE_F32);
-                // XXX if (threaded) {
-                // XXX     psMutexInit(out1->variance);
-                // XXX }
             }
             psImageInit(out1->variance, 0.0);
@@ -1207,14 +1200,8 @@
         if (!out2->image) {
             out2->image = psImageAlloc(numCols, numRows, PS_TYPE_F32);
-            // XXX if (threaded) {
-            // XXX     psMutexInit(out2->image);
-            // XXX }
         }
         if (ro2->variance) {
             if (!out2->variance) {
                 out2->variance = psImageAlloc(numCols, numRows, PS_TYPE_F32);
-                // XXX if (threaded) {
-                // XXX     psMutexInit(out2->variance);
-                // XXX }
             }
             psImageInit(out2->variance, 0.0);
@@ -1223,7 +1210,4 @@
     psImage *convMask = NULL;           // Convolved mask image (common to inputs 1 and 2)
     if (subMask) {
-        // XXX if (threaded) {
-        // XXX     psMutexInit(subMask);
-        // XXX }
         if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
             if (!out1->mask) {
@@ -1249,16 +1233,12 @@
 
     psImage *sys1 = NULL, *sys2 = NULL; // Systematic error images
+#ifdef USE_SYS_ERR
     if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
         sys1 = subtractionSysErrImage(ro1->image, sysError);
-        // XXX if (threaded && sys1) {
-        // XXX     psMutexInit(sys1);
-        // XXX }
     }
     if (kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
         sys2 = subtractionSysErrImage(ro2->image, sysError);
-        // XXX if (threaded && sys2) {
-        // XXX     psMutexInit(sys2);
-        // XXX }
-    }
+    }
+#endif
 
     int size = kernels->size;           // Half-size of kernel
@@ -1309,26 +1289,7 @@
                 psArrayAdd(args, 1, (pmReadout*)ro1); // Casting away const
                 psArrayAdd(args, 1, (pmReadout*)ro2); // Casting away const
-                // Since adding to the array can impact the reference count, we need to lock
-                // XXX if (sys1) {
-                // XXX     psMutexLock(sys1);
-                // XXX }
                 psArrayAdd(args, 1, sys1);
-                // XXX if (sys1) {
-                // XXX     psMutexUnlock(sys1);
-                // XXX }
-                // XXX if (sys2) {
-                // XXX     psMutexLock(sys2);
-                // XXX }
                 psArrayAdd(args, 1, sys2);
-                // XXX if (sys2) {
-                // XXX     psMutexUnlock(sys2);
-                // XXX }
-                // XXX if (subMask) {
-                // XXX     psMutexLock(subMask);
-                // XXX }
                 psArrayAdd(args, 1, subMask);
-                // XXX if (subMask) {
-                // XXX     psMutexUnlock(subMask);
-                // XXX }
                 PS_ARRAY_ADD_SCALAR(args, maskBad, PS_TYPE_IMAGE_MASK);
                 PS_ARRAY_ADD_SCALAR(args, maskPoor, PS_TYPE_IMAGE_MASK);
@@ -1369,14 +1330,4 @@
             psFree(job);
         }
-
-        // XXX if (subMask) {
-        // XXX     psMutexDestroy(subMask);
-        // XXX }
-        // XXX if (sys1) {
-        // XXX     psMutexDestroy(sys1);
-        // XXX }
-        // XXX if (sys2) {
-        // XXX     psMutexDestroy(sys2);
-        // XXX }
     }
     psImageConvolveSetThreads(oldThreads);