Index: trunk/psModules/src/detrend/pmDark.c
===================================================================
--- trunk/psModules/src/detrend/pmDark.c	(revision 24869)
+++ trunk/psModules/src/detrend/pmDark.c	(revision 27597)
@@ -38,10 +38,10 @@
     if (!item) {
         pmChip *chip = cell->parent; // Parent chip
-	psAssert(chip, "cell is missing chip \n");
+        psAssert(chip, "cell is missing chip \n");
 
         item = psMetadataLookup(chip->concepts, name);
         if (!item) {
             pmFPA *fpa = chip->parent; // Parent FPA
-	    psAssert(fpa, "chip is missing fpa \n");
+            psAssert(fpa, "chip is missing fpa \n");
 
             item = psMetadataLookup(fpa->concepts, name);
@@ -68,5 +68,5 @@
 
     psArray *words = psStringSplitArray(rule, " ", false);
-    
+
     // we should have a rule of the form (concept) OP (concept) OP (concept) ...
     // for now, the only allowed OP is * (eventually, we can steal code from opihi for a better
@@ -74,31 +74,31 @@
 
     if (words->n % 2 == 0) {
-	psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
-	psFree(words);
-	return false;
+        psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
+        psFree(words);
+        return false;
     }
 
     for (int i = 1; i < words->n; i+=2) {
-	if (strcmp((char *)words->data[i], "*")) {
-	    psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
-	    psFree(words);
-	    return false;
-	}
-    }
-    
+        if (strcmp((char *)words->data[i], "*")) {
+            psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
+            psFree(words);
+            return false;
+        }
+    }
+
     if (!ordinateParseConcept(value, readout, words->data[0])) {
-	psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
-	psFree(words);
-	return false;
+        psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
+        psFree(words);
+        return false;
     }
 
     double value2 = 0.0;
     for (int i = 2; i < words->n; i+=2) {
-	if (!ordinateParseConcept(&value2, readout, words->data[i])) {
-	    psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
-	    psFree(words);
-	    return false;
-	}
-	*value *= value2;
+        if (!ordinateParseConcept(&value2, readout, words->data[i])) {
+            psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
+            psFree(words);
+            return false;
+        }
+        *value *= value2;
     }
     psFree(words);
@@ -123,13 +123,13 @@
 
     if (rule) {
-	if (!ordinateParseRule(value, readout, name, rule)) {
-	    psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
-	    return false;
-	}
+        if (!ordinateParseRule(value, readout, name, rule)) {
+            psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
+            return false;
+        }
     } else {
-	if (!ordinateParseConcept(value, readout, name)) {
-	    psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
-	    return false;
-	}
+        if (!ordinateParseConcept(value, readout, name)) {
+            psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
+            return false;
+        }
     }
 
@@ -188,8 +188,8 @@
         double normValue;            // Normalisation value
         if (!ordinateLookup(&normValue, &inRange, normConcept, NULL, false, NAN, NAN, readout)) {
-	    psError(PM_ERR_CONFIG, false, "problem finding concept %s for DARK.NORM", normConcept);
-	    return false;
-	}
-	if (!isfinite(normValue)) {
+            psError(PM_ERR_CONFIG, false, "problem finding concept %s for DARK.NORM", normConcept);
+            return false;
+        }
+        if (!isfinite(normValue)) {
             psWarning("Unable to find acceptable value of %s for readout %d", normConcept, i);
             roMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
@@ -231,9 +231,9 @@
             double value = NAN;          // Value of ordinate
             if (!ordinateLookup(&value, &inRange, ord->name, ord->rule, ord->scale, ord->min, ord->max, readout)) {
-		psError(PM_ERR_CONFIG, false, "problem finding rule for DARK.ORDINATE %s", ord->name);
-		return false;
-	    }
-	    if (!isfinite(value)) {
-		psWarning("Unable to find acceptable value of DARK.ORDINATE %s for readout %d", ord->name, i);
+                psError(PM_ERR_CONFIG, false, "problem finding rule for DARK.ORDINATE %s", ord->name);
+                return false;
+            }
+            if (!isfinite(value)) {
+                psWarning("Unable to find acceptable value of DARK.ORDINATE %s for readout %d", ord->name, i);
                 roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
                 val->data.F32[i] = NAN;
@@ -242,5 +242,5 @@
             }
             if (!inRange) {
-		psWarning("Value of DARK.ORDINATE %s for readout %d is out of range", ord->name, i);
+                psWarning("Value of DARK.ORDINATE %s for readout %d is out of range", ord->name, i);
                 roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
                 val->data.F32[i] = NAN;
@@ -349,9 +349,4 @@
     PS_ASSERT_INT_NONNEGATIVE(iter, false);
     PS_ASSERT_FLOAT_LARGER_THAN(rej, 0.0, false);
-
-    pthread_t id = pthread_self();
-    char name[64];
-    sprintf (name, "%x", (unsigned int) id);
-    psTimerStart (name);
 
     bool mdok = false;
@@ -433,6 +428,6 @@
             }
 
-	    pmDarkVisualPixelFit(pixels, mask);
-	    pmDarkVisualPixelModel(poly, values);
+            pmDarkVisualPixelFit(pixels, mask);
+            pmDarkVisualPixelModel(poly, values);
 
             for (int k = 0; k < poly->coeff->n; k++) {
@@ -537,9 +532,9 @@
             return false;
         }
-	if (!isfinite(value)) {
+        if (!isfinite(value)) {
             psError(PS_ERR_UNKNOWN, true, "Value for DARK.ORDINATE %s is NAN", ord->name);
             psFree(values);
             return false;
-	}
+        }
         values->data.F32[i] = value;
     }
@@ -792,10 +787,10 @@
             psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_NAME, 0, "DARK.ORDINATE name", ord->name);
 
-	    // XXX write a dummy value if ord->rule == NULL? (eg, NONE)
-	    if (ord->rule) {
-		psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", ord->rule);
-	    } else {
-		psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", "NONE");
-	    }
+            // XXX write a dummy value if ord->rule == NULL? (eg, NONE)
+            if (ord->rule) {
+                psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", ord->rule);
+            } else {
+                psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", "NONE");
+            }
 
             psMetadataAddS32(row, PS_LIST_TAIL, PM_DARK_FITS_ORDER, 0, "Polynomial order", ord->order);
@@ -975,12 +970,12 @@
               ord->max = psMetadataLookupF32(NULL, row, PM_DARK_FITS_MAX);
 
-	      // load the ordinate rule; it is not an error if this field is missing or NULL
-	      // a NULL rule means 'use the name as the single concept'
+              // load the ordinate rule; it is not an error if this field is missing or NULL
+              // a NULL rule means 'use the name as the single concept'
               const char *rule = psMetadataLookupStr(&mdok, row, PM_DARK_FITS_RULE);
-	      if (!rule || !strcasecmp(rule, "NONE")) {
-		  ord->rule = NULL;
-	      } else {
-		  ord->rule = psStringCopy(rule);
-	      }
+              if (!rule || !strcasecmp(rule, "NONE")) {
+                  ord->rule = NULL;
+              } else {
+                  ord->rule = psStringCopy(rule);
+              }
               ordinates->data[i] = ord;
           }
@@ -1009,5 +1004,5 @@
 // this init function only gets the ordinates for the first readout...
 bool pmDarkVisualInit(psArray *values) {
-    
+
     if (!pmVisualIsVisual()) return true;
 
@@ -1018,22 +1013,22 @@
     int nOrders = 0;
     for (int i = 0; i < values->n; i++) {
-	psVector *vect = values->data[i];
-	if (!nOrders) {
-	    nOrders = vect->n;
-	} else {
-	    psAssert (nOrders == vect->n, "mismatch in order vector lengths");
-	}
+        psVector *vect = values->data[i];
+        if (!nOrders) {
+            nOrders = vect->n;
+        } else {
+            psAssert (nOrders == vect->n, "mismatch in order vector lengths");
+        }
     }
     xVectors = psArrayAlloc(nOrders);
     for (int i = 0; i < nOrders; i++) {
-	xVectors->data[i] = psVectorAlloc(values->n, PS_TYPE_F32);
+        xVectors->data[i] = psVectorAlloc(values->n, PS_TYPE_F32);
     }
 
     for (int i = 0; i < values->n; i++) {
-	psVector *vect = values->data[i];
-	for (int j = 0; j < vect->n; j++) {
-	    psVector *xVec = xVectors->data[j];
-	    xVec->data.F32[i] = vect->data.F32[j];
-	}
+        psVector *vect = values->data[i];
+        for (int j = 0; j < vect->n; j++) {
+            psVector *xVec = xVectors->data[j];
+            xVec->data.F32[i] = vect->data.F32[j];
+        }
     }
 
@@ -1041,8 +1036,8 @@
 
     kapa = psAlloc(nKapa*sizeof(int));
-    
+
     for (int i = 0; i < nKapa; i++) {
-	kapa[i] = -1;
-	pmVisualInitWindow(&kapa[i], "ppmerge");
+        kapa[i] = -1;
+        pmVisualInitWindow(&kapa[i], "ppmerge");
     }
     return true;
@@ -1063,33 +1058,33 @@
 
     for (int i = 0; i < xVectors->n; i++) {
-	psVector *x = xVectors->data[i];
-
-	// generate vectors of the unmasked values
-	int nSub = 0;
-	for (int j = 0; j < pixels->n; j++) {
-	    if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) continue;
-	    xSub->data.F32[nSub] = x->data.F32[j];
-	    ySub->data.F32[nSub] = pixels->data.F32[j];
-	    nSub ++;
-	}
-	xSub->n = ySub->n = nSub;
-	
-	// plot the unmasked values
-	pmVisualScaleGraphdata (&graphdata, xSub, ySub, false);
-	KapaSetGraphData(kapa[i], &graphdata);
-	KapaSetLimits(kapa[i], &graphdata);
-	KapaClearPlots (kapa[i]);
-
-	KapaSetFont (kapa[i], "courier", 14);
-	KapaBox (kapa[i], &graphdata);
-	KapaSendLabel (kapa[i], "ordinate", KAPA_LABEL_XM);
-	KapaSendLabel (kapa[i], "pixel values", KAPA_LABEL_YM);
-
-	graphdata.color = KapaColorByName("black");
-	graphdata.style = 2;
-	graphdata.ptype = 2;
-	KapaPrepPlot  (kapa[i], xSub->n, &graphdata);
-	KapaPlotVector(kapa[i], xSub->n, xSub->data.F32, "x");
-	KapaPlotVector(kapa[i], xSub->n, ySub->data.F32, "y");
+        psVector *x = xVectors->data[i];
+
+        // generate vectors of the unmasked values
+        int nSub = 0;
+        for (int j = 0; j < pixels->n; j++) {
+            if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) continue;
+            xSub->data.F32[nSub] = x->data.F32[j];
+            ySub->data.F32[nSub] = pixels->data.F32[j];
+            nSub ++;
+        }
+        xSub->n = ySub->n = nSub;
+
+        // plot the unmasked values
+        pmVisualScaleGraphdata (&graphdata, xSub, ySub, false);
+        KapaSetGraphData(kapa[i], &graphdata);
+        KapaSetLimits(kapa[i], &graphdata);
+        KapaClearPlots (kapa[i]);
+
+        KapaSetFont (kapa[i], "courier", 14);
+        KapaBox (kapa[i], &graphdata);
+        KapaSendLabel (kapa[i], "ordinate", KAPA_LABEL_XM);
+        KapaSendLabel (kapa[i], "pixel values", KAPA_LABEL_YM);
+
+        graphdata.color = KapaColorByName("black");
+        graphdata.style = 2;
+        graphdata.ptype = 2;
+        KapaPrepPlot  (kapa[i], xSub->n, &graphdata);
+        KapaPlotVector(kapa[i], xSub->n, xSub->data.F32, "x");
+        KapaPlotVector(kapa[i], xSub->n, ySub->data.F32, "y");
     }
     pmVisualAskUser (&plotFlag);
@@ -1110,18 +1105,18 @@
 
     for (int i = 0; i < values->n; i++) {
-	psVector *coord = values->data[i];
-	yFit->data.F32[i] = psPolynomialMDEval (poly, coord);
+        psVector *coord = values->data[i];
+        yFit->data.F32[i] = psPolynomialMDEval (poly, coord);
     }
 
     for (int i = 0; i < xVectors->n; i++) {
-	psVector *xFit = xVectors->data[i];
-
-	KapaGetGraphData(kapa[i], &graphdata);
-	graphdata.color = KapaColorByName("red");
-	graphdata.style = 2;
-	graphdata.ptype = 7;
-	KapaPrepPlot  (kapa[i], xFit->n, &graphdata);
-	KapaPlotVector(kapa[i], xFit->n, xFit->data.F32, "x");
-	KapaPlotVector(kapa[i], xFit->n, yFit->data.F32, "y");
+        psVector *xFit = xVectors->data[i];
+
+        KapaGetGraphData(kapa[i], &graphdata);
+        graphdata.color = KapaColorByName("red");
+        graphdata.style = 2;
+        graphdata.ptype = 7;
+        KapaPrepPlot  (kapa[i], xFit->n, &graphdata);
+        KapaPlotVector(kapa[i], xFit->n, xFit->data.F32, "x");
+        KapaPlotVector(kapa[i], xFit->n, yFit->data.F32, "y");
     }
     pmVisualAskUser (&plotFlag);
@@ -1132,5 +1127,5 @@
 
     for (int i = 0; i < nKapa; i++) {
-	KapaClose(kapa[i]);
+        KapaClose(kapa[i]);
     }
     psFree (kapa);