Index: /trunk/psModules/src/detrend/pmFlatNormalize.c
===================================================================
--- /trunk/psModules/src/detrend/pmFlatNormalize.c	(revision 7178)
+++ /trunk/psModules/src/detrend/pmFlatNormalize.c	(revision 7179)
@@ -12,5 +12,5 @@
                           const psImage *fluxLevels, // Fluxes for each integration (row) and chip (col)
                           unsigned int maxIter, // Maximum number of iterations
-                          double tolerance   // Tolerance level before dying
+                          float tolerance   // Tolerance level before dying
                          )
 {
@@ -20,10 +20,10 @@
     // Sanity checks
     assert(chipGains->n == numChips);
-    assert(chipGains->type.type == PS_TYPE_F64);
+    assert(chipGains->type.type == PS_TYPE_F32);
     assert(maxIter >= 1);
     assert(tolerance > 0);
 
     // Take the logarithms
-    psImage *flux = psImageCopy(NULL, fluxLevels, PS_TYPE_F64); // Copy of the input flux levels matrix
+    psImage *flux = psImageCopy(NULL, fluxLevels, PS_TYPE_F32); // Copy of the input flux levels matrix
     psImage *fluxMask = psImageAlloc(numChips, numSources, PS_TYPE_U8); // Mask for bad measurements
     psImageInit(fluxMask, 0);
@@ -35,12 +35,12 @@
     psVectorInit(sourceMask, 0);
     for (int i = 0; i < numChips; i++) {
-        if (isfinite(chipGains->data.F64[i]) && chipGains->data.F64[i] > 0) {
-            chipGains->data.F64[i] = log(chipGains->data.F64[i]);
+        if (isfinite(chipGains->data.F32[i]) && chipGains->data.F32[i] > 0) {
+            chipGains->data.F32[i] = log(chipGains->data.F32[i]);
         } else {
-            chipGains->data.F64[i] = 0.0; // Take a wild guess
+            chipGains->data.F32[i] = 0.0; // Take a wild guess
             #if 0
             // Blank out this chip
             gainMask->data.U8[i] = 1;
-            chipGains->data.F64[i] = NAN;
+            chipGains->data.F32[i] = NAN;
             #endif
 
@@ -48,18 +48,18 @@
 
         for (int j = 0; j < numSources; j++) {
-            if (isfinite(flux->data.F64[j][i]) && flux->data.F64[j][i] > 0) {
-                flux->data.F64[j][i] = log(flux->data.F64[j][i]);
+            if (isfinite(flux->data.F32[j][i]) && flux->data.F32[j][i] > 0) {
+                flux->data.F32[j][i] = log(flux->data.F32[j][i]);
             } else {
                 // Blank out this measurement
                 fluxMask->data.U8[j][i] = 1;
-                flux->data.F64[j][i] = NAN;
+                flux->data.F32[j][i] = NAN;
             }
         }
     }
 
-    double diff = INFINITY;             // Difference from previous iteration
-    psVector *sourceFlux = psVectorAlloc(numSources, PS_TYPE_F64); // The flux in each integration
+    float diff = INFINITY;             // Difference from previous iteration
+    psVector *sourceFlux = psVectorAlloc(numSources, PS_TYPE_F32); // The flux in each integration
     sourceFlux->n = numSources;
-    psVector *oldSourceFlux = psVectorAlloc(numSources, PS_TYPE_F64); // The fluxes in the previous iteration
+    psVector *oldSourceFlux = psVectorAlloc(numSources, PS_TYPE_F32); // The fluxes in the previous iteration
     oldSourceFlux->n = numSources;
     psVectorInit(oldSourceFlux, 0.0);
@@ -69,5 +69,5 @@
 
         // Improve on the fluxes
-        double sumFlux = 0.0;           // Total fluxes
+        float sumFlux = 0.0;           // Total fluxes
         long numFluxes = 0;             // Number of fluxes
         for (int i = 0; i < numSources; i++) {
@@ -77,23 +77,23 @@
             }
             numFluxes++;
-            double sum = 0.0;           // Sum of F_ij - G_j
+            float sum = 0.0;           // Sum of F_ij - G_j
             int number = 0;             // Number of chips contributing
             for (int j = 0; j < numChips; j++) {
                 if (!gainMask->data.U8[j] && !fluxMask->data.U8[i][j]) {
-                    sum += flux->data.F64[i][j] - chipGains->data.F64[j];
+                    sum += flux->data.F32[i][j] - chipGains->data.F32[j];
                     number++;
                 }
             }
             if (number > 0) {
-                sourceFlux->data.F64[i] = sum / (double)number;
+                sourceFlux->data.F32[i] = sum / (float)number;
             } else {
                 sourceMask->data.U8[i] = 1;
-                sourceFlux->data.F64[i] = NAN;
+                sourceFlux->data.F32[i] = NAN;
             }
-            sumFlux += exp(sourceFlux->data.F64[i]);
-            psTrace(__func__, 7, "Flux for exposure %d is %f\n", i, exp(sourceFlux->data.F64[i]));
+            sumFlux += exp(sourceFlux->data.F32[i]);
+            psTrace(__func__, 7, "Flux for exposure %d is %f\n", i, exp(sourceFlux->data.F32[i]));
         }
         // Normalise the mean to unity
-        sumFlux /= (double)numFluxes;
+        sumFlux /= (float)numFluxes;
         sumFlux = log(sumFlux);
         for (int i = 0; i < numSources; i++) {
@@ -101,6 +101,6 @@
                 continue;
             }
-            sourceFlux->data.F64[i] -= sumFlux;
-            diff += abs((sourceFlux->data.F64[i] - oldSourceFlux->data.F64[i]) / sourceFlux->data.F64[i]);
+            sourceFlux->data.F32[i] -= sumFlux;
+            diff += abs((sourceFlux->data.F32[i] - oldSourceFlux->data.F32[i]) / sourceFlux->data.F32[i]);
         }
 
@@ -110,19 +110,19 @@
                 continue;
             }
-            double sum = 0.0;           // Sum of F_ji - S_j
+            float sum = 0.0;           // Sum of F_ji - S_j
             int number = 0;             // Numer of sources contributing
             for (int j = 0; j < numSources; j++) {
                 if (!fluxMask->data.U8[j][i]) {
-                    sum += flux->data.F64[j][i] - sourceFlux->data.F64[j];
+                    sum += flux->data.F32[j][i] - sourceFlux->data.F32[j];
                     number++;
                 }
             }
             if (number > 0) {
-                chipGains->data.F64[i] = sum / (double)number;
+                chipGains->data.F32[i] = sum / (float)number;
             } else {
                 gainMask->data.U8[i] = 1;
-                chipGains->data.F64[i] = NAN;
+                chipGains->data.F32[i] = NAN;
             }
-            psTrace(__func__, 7, "Gain for chip %d is %f\n", i, exp(chipGains->data.F64[i]));
+            psTrace(__func__, 7, "Gain for chip %d is %f\n", i, exp(chipGains->data.F32[i]));
         }
 
@@ -141,10 +141,10 @@
     for (int i = 0; i < numChips; i++) {
         if (!gainMask->data.U8[i]) {
-            chipGains->data.F64[i] = exp(chipGains->data.F64[i]);
+            chipGains->data.F32[i] = exp(chipGains->data.F32[i]);
         }
     }
     for (int i = 0; i < numSources; i++) {
         if (!sourceMask->data.U8[i]) {
-            sourceFlux->data.F64[i] = exp(sourceFlux->data.F64[i]);
+            sourceFlux->data.F32[i] = exp(sourceFlux->data.F32[i]);
         }
     }
Index: /trunk/psModules/src/detrend/pmFlatNormalize.h
===================================================================
--- /trunk/psModules/src/detrend/pmFlatNormalize.h	(revision 7178)
+++ /trunk/psModules/src/detrend/pmFlatNormalize.h	(revision 7179)
@@ -2,4 +2,5 @@
 #define PM_FLAT_NORMALIZE_H
 
+#include "pslib.h"
 
 // Normalise the flat-field measurements (f_ij = g_i s_j where f_ij is the flux recorded for chip i and
@@ -10,5 +11,5 @@
                           const psImage *fluxLevels, // Fluxes for each integration (row) and chip (col)
                           unsigned int maxIter, // Maximum number of iterations
-                          double tolerance   // Tolerance level before dying
+                          float tolerance // Tolerance level before dying
                          );