Changeset 21236

Timestamp:

Jan 29, 2009, 5:31:30 PM (17 years ago)

Author:

Paul Price

Message:

Changing 'weight' to 'variance'. Mostly propagating psModules changes.

Location:

branches/pap_branch_20090128/ppStack/src

Files:

• ppStack.h (modified) (2 diffs)
• ppStackArguments.c (modified) (4 diffs)
• ppStackCamera.c (modified) (6 diffs)
• ppStackLoop.c (modified) (7 diffs)
• ppStackMatch.c (modified) (4 diffs)
• ppStackThread.c (modified) (6 diffs)

branches/pap_branch_20090128/ppStack/src/ppStack.h

@@ -38 +38 @@
     psArray *imageFits;                 // FITS file pointers for images
     psArray *maskFits;                  // FITS file pointers for masks
-    psArray *weightFits;                // FITS file pointers for weights
+    psArray *varianceFits;                // FITS file pointers for variances
 } ppStackThreadData;
 
@@ -45 +45 @@
                                           const psArray *imageNames, // Names of images to read
                                           const psArray *maskNames, // Names of masks to read
-                                          const psArray *weightNames, // Names of weight maps to read
+                                          const psArray *varianceNames, // Names of variance maps to read
                                           const pmConfig *config // Configuration
     );

branches/pap_branch_20090128/ppStack/src/ppStackArguments.c

@@ -24 +24 @@
             "\tIMAGE(STR):     Image filename\n"
             "\tMASK(STR):      Mask filename\n"
-            "\tWEIGHT(STR):    Weight map filename\n"
+            "\tVARIANCE(STR):  Variance map filename\n"
             "\tPSF(STR):       PSF filename\n"
             "\tSOURCES(STR):   Sources filename\n"
@@ -151 +151 @@
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask-poor", 0, "Mask value to give poor pixels", NULL);
     psMetadataAddF32(arguments, PS_LIST_TAIL, "-threshold-mask", 0, "Threshold for mask deconvolution", NAN);
-    psMetadataAddF32(arguments, PS_LIST_TAIL, "-poor-frac", 0, "Fraction of weight for poor pixels", NAN);
+    psMetadataAddF32(arguments, PS_LIST_TAIL, "-poor-frac", 0, "Fraction of variance for poor pixels", NAN);
     psMetadataAddF32(arguments, PS_LIST_TAIL, "-image-rej", 0,
                      "Pixel rejection fraction threshold for rejecting entire image", NAN);
@@ -182 +182 @@
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-image", 0, "Suffix for temporary images", NULL);
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-mask", 0, "Suffix for temporary masks", NULL);
-    psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-weight", 0, "Suffix for temporary weight maps", NULL);
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-temp-variance", 0, "Suffix for temporary variance maps", NULL);
     psMetadataAddBool(arguments, PS_LIST_TAIL, "-temp-delete", 0,
                       "Delete temporary files on completion?", false);
@@ -281 +281 @@
     VALUE_ARG_RECIPE_INT("-renorm-num", "RENORM.NUM", S32, 0);
     VALUE_ARG_RECIPE_FLOAT("-renorm-width", "RENORM.WIDTH", F32);
-    valueArgRecipeStr(arguments, recipe, "-renorm-mean", "RENORM.MEAN", recipe);
+    valueArgRecipeStr(arguments, recipe, "-renorm-mean",  "RENORM.MEAN", recipe);
     valueArgRecipeStr(arguments, recipe, "-renorm-stdev", "RENORM.STDEV", recipe);
 
-    valueArgRecipeStr(arguments, recipe, "-temp-image",  "TEMP.IMAGE",  recipe);
-    valueArgRecipeStr(arguments, recipe, "-temp-mask",   "TEMP.MASK",   recipe);
-    valueArgRecipeStr(arguments, recipe, "-temp-weight", "TEMP.WEIGHT", recipe);
+    valueArgRecipeStr(arguments, recipe, "-temp-image",    "TEMP.IMAGE",  recipe);
+    valueArgRecipeStr(arguments, recipe, "-temp-mask",     "TEMP.MASK",   recipe);
+    valueArgRecipeStr(arguments, recipe, "-temp-variance", "TEMP.VARIANCE", recipe);
 
     if (psMetadataLookupBool(NULL, arguments, "-temp-delete") ||

branches/pap_branch_20090128/ppStack/src/ppStackCamera.c

@@ -71 +71 @@
 bool ppStackCamera(pmConfig *config)
 {
-    bool haveWeights = false;           // Do we have weight maps?
+    bool haveVariances = false;           // Do we have variance maps?
     bool havePSFs = false;              // Do we have PSFs?
 
@@ -97 +97 @@
         bool mdok;
         psString mask = psMetadataLookupStr(&mdok, input, "MASK"); // Name of mask
-        psString weight = psMetadataLookupStr(&mdok, input, "WEIGHT"); // Name of weight map
+        psString variance = psMetadataLookupStr(&mdok, input, "VARIANCE"); // Name of variance map
         psString psf = psMetadataLookupStr(&mdok, input, "PSF"); // Name of PSF
         psString sources = psMetadataLookupStr(&mdok, input, "SOURCES"); // Name of sources
@@ -140 +140 @@
         }
 
-        // Optionally add the weight file
-        if (weight && strlen(weight) > 0) {
-            haveWeights = true;
-            psArray *weightFiles = psArrayAlloc(1); // Array of filenames for this FPA
-            weightFiles->data[0] = psMemIncrRefCounter(weight);
-            psMetadataAddArray(config->arguments, PS_LIST_TAIL, "WEIGHT.FILENAMES", PS_META_REPLACE,
-                               "Filenames of weight files", weightFiles);
-            psFree(weightFiles);
+        // Optionally add the variance file
+        if (variance && strlen(variance) > 0) {
+            haveVariances = true;
+            psArray *varianceFiles = psArrayAlloc(1); // Array of filenames for this FPA
+            varianceFiles->data[0] = psMemIncrRefCounter(variance);
+            psMetadataAddArray(config->arguments, PS_LIST_TAIL, "VARIANCE.FILENAMES", PS_META_REPLACE,
+                               "Filenames of variance files", varianceFiles);
+            psFree(varianceFiles);
 
             bool status;
-            pmFPAfile *weightFile = pmFPAfileBindFromArgs(&status, imageFile, config, "PPSTACK.INPUT.WEIGHT",
-                                                          "WEIGHT.FILENAMES");
+            pmFPAfile *varianceFile = pmFPAfileBindFromArgs(&status, imageFile, config,
+                                                            "PPSTACK.INPUT.VARIANCE", "VARIANCE.FILENAMES");
             if (!status) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to define file from weight %d (%s)", i, weight);
-                return false;
-            }
-            if (weightFile->type != PM_FPA_FILE_WEIGHT) {
-                psError(PS_ERR_IO, true, "PPSTACK.INPUT.WEIGHT is not of type WEIGHT");
+                psError(PS_ERR_UNKNOWN, false, "Unable to define file from variance %d (%s)", i, variance);
+                return false;
+            }
+            if (varianceFile->type != PM_FPA_FILE_VARIANCE) {
+                psError(PS_ERR_IO, true, "PPSTACK.INPUT.VARIANCE is not of type VARIANCE");
                 return false;
             }
@@ -217 +217 @@
 #if 0
         // Output convolved files
-        pmFPAfile *outconvImage  = defineOutputConvolved("PPSTACK.OUTCONV", imageFile->fpa, config,
+        pmFPAfile *outconvImage    = defineOutputConvolved("PPSTACK.OUTCONV", imageFile->fpa, config,
+                                                           PM_FPA_FILE_IMAGE);
+        pmFPAfile *outconvMask     = defineOutputConvolved("PPSTACK.OUTCONV.MASK", imageFile->fpa, config,
+                                                           PM_FPA_FILE_MASK);
+        pmFPAfile *outconvVariance = defineOutputConvolved("PPSTACK.OUTCONV.VARIANCE", imageFile->fpa, config,
+                                                           PM_FPA_FILE_VARIANCE);
+        if (!outconvImage || !outconvMask || !outconvVariance) {
+            return false;
+        }
+
+        // Input convolved files
+        pmFPAfile *inconvImage    = defineInputConvolved("PPSTACK.INCONV", outconvImage, config,
                                                          PM_FPA_FILE_IMAGE);
-        pmFPAfile *outconvMask   = defineOutputConvolved("PPSTACK.OUTCONV.MASK", imageFile->fpa, config,
+        pmFPAfile *inconvMask     = defineInputConvolved("PPSTACK.INCONV.MASK", outconvMask, config,
                                                          PM_FPA_FILE_MASK);
-        pmFPAfile *outconvWeight = defineOutputConvolved("PPSTACK.OUTCONV.WEIGHT", imageFile->fpa, config,
-                                                         PM_FPA_FILE_WEIGHT);
-        if (!outconvImage || !outconvMask || !outconvWeight) {
-            return false;
-        }
-
-        // Input convolved files
-        pmFPAfile *inconvImage  = defineInputConvolved("PPSTACK.INCONV", outconvImage, config,
-                                                       PM_FPA_FILE_IMAGE);
-        pmFPAfile *inconvMask   = defineInputConvolved("PPSTACK.INCONV.MASK", outconvMask, config,
-                                                       PM_FPA_FILE_MASK);
-        pmFPAfile *inconvWeight = defineInputConvolved("PPSTACK.INCONV.WEIGHT", outconvWeight, config,
-                                                       PM_FPA_FILE_WEIGHT);
-        if (!inconvImage || !inconvMask || !inconvWeight) {
+        pmFPAfile *inconvVariance = defineInputConvolved("PPSTACK.INCONV.VARIANCE", outconvVariance, config,
+                                                         PM_FPA_FILE_VARIANCE);
+        if (!inconvImage || !inconvMask || !inconvVariance) {
             return false;
         }
@@ -246 +246 @@
         psMetadataRemoveKey(config->arguments, "MASK.FILENAMES");
     }
-    if (psMetadataLookup(config->arguments, "WEIGHT.FILENAMES")) {
-        psMetadataRemoveKey(config->arguments, "WEIGHT.FILENAMES");
+    if (psMetadataLookup(config->arguments, "VARIANCE.FILENAMES")) {
+        psMetadataRemoveKey(config->arguments, "VARIANCE.FILENAMES");
     }
     if (psMetadataLookup(config->arguments, "PSF.FILENAMES")) {
@@ -295 +295 @@
     outMask->save = true;
 
-    // Output weight
-    if (haveWeights) {
-        pmFPAfile *outWeight = pmFPAfileDefineOutput(config, output->fpa, "PPSTACK.OUTPUT.WEIGHT");
-        if (!outWeight) {
-            psError(PS_ERR_IO, false, _("Unable to generate output file from PPSTACK.OUTPUT.WEIGHT"));
-            return false;
-        }
-        if (outWeight->type != PM_FPA_FILE_WEIGHT) {
-            psError(PS_ERR_IO, true, "PPSTACK.OUTPUT.WEIGHT is not of type WEIGHT");
-            return false;
-        }
-        outWeight->save = true;
+    // Output variance
+    if (haveVariances) {
+        pmFPAfile *outVariance = pmFPAfileDefineOutput(config, output->fpa, "PPSTACK.OUTPUT.VARIANCE");
+        if (!outVariance) {
+            psError(PS_ERR_IO, false, _("Unable to generate output file from PPSTACK.OUTPUT.VARIANCE"));
+            return false;
+        }
+        if (outVariance->type != PM_FPA_FILE_VARIANCE) {
+            psError(PS_ERR_IO, true, "PPSTACK.OUTPUT.VARIANCE is not of type VARIANCE");
+            return false;
+        }
+        outVariance->save = true;
     }
 

branches/pap_branch_20090128/ppStack/src/ppStackLoop.c

@@ -24 +24 @@
 
 // Files required for the convolution
-static char *convolveFiles[] = { "PPSTACK.INPUT", "PPSTACK.INPUT.MASK", "PPSTACK.INPUT.WEIGHT", NULL };
+static char *convolveFiles[] = { "PPSTACK.INPUT", "PPSTACK.INPUT.MASK", "PPSTACK.INPUT.VARIANCE", NULL };
 
 // Output files for the combination
-static char *combineFiles[] = { "PPSTACK.OUTPUT", "PPSTACK.OUTPUT.MASK", "PPSTACK.OUTPUT.WEIGHT",
+static char *combineFiles[] = { "PPSTACK.OUTPUT", "PPSTACK.OUTPUT.MASK", "PPSTACK.OUTPUT.VARIANCE",
                                 "PPSTACK.OUTPUT.JPEG1", "PPSTACK.OUTPUT.JPEG2", NULL };
 
@@ -204 +204 @@
     const char *tempImage = psMetadataLookupStr(NULL, recipe, "TEMP.IMAGE"); // Suffix for temporary images
     const char *tempMask = psMetadataLookupStr(NULL, recipe, "TEMP.MASK"); // Suffix for temporary masks
-    const char *tempWeight = psMetadataLookupStr(NULL, recipe, "TEMP.WEIGHT"); // Suffix for temp weight maps
-    if (!tempImage || !tempMask || !tempWeight) {
+    const char *tempVariance = psMetadataLookupStr(NULL, recipe, "TEMP.VARIANCE"); // Suffix for temp variance maps
+    if (!tempImage || !tempMask || !tempVariance) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                "Unable to find TEMP.IMAGE, TEMP.MASK and TEMP.WEIGHT in recipe");
+                "Unable to find TEMP.IMAGE, TEMP.MASK and TEMP.VARIANCE in recipe");
         return false;
     }
@@ -381 +381 @@
     psArray *imageNames = psArrayAlloc(num);
     psArray *maskNames = psArrayAlloc(num);
-    psArray *weightNames = psArrayAlloc(num);
+    psArray *varianceNames = psArrayAlloc(num);
     for (int i = 0; i < num; i++) {
-        psString imageName = NULL, maskName = NULL, weightName = NULL; // Names for convolved images
+        psString imageName = NULL, maskName = NULL, varianceName = NULL; // Names for convolved images
         psStringAppend(&imageName, "%s/%s.%d.%s", tempDir, tempName, i, tempImage);
         psStringAppend(&maskName, "%s/%s.%d.%s", tempDir, tempName, i, tempMask);
-        psStringAppend(&weightName, "%s/%s.%d.%s", tempDir, tempName, i, tempWeight);
-        psTrace("ppStack", 5, "Temporary files: %s %s %s\n", imageName, maskName, weightName);
+        psStringAppend(&varianceName, "%s/%s.%d.%s", tempDir, tempName, i, tempVariance);
+        psTrace("ppStack", 5, "Temporary files: %s %s %s\n", imageName, maskName, varianceName);
         imageNames->data[i] = imageName;
         maskNames->data[i] = maskName;
-        weightNames->data[i] = weightName;
+        varianceNames->data[i] = varianceName;
     }
     // Free the outputName that we grabbed above to set up tempName.
@@ -481 +481 @@
         writeImage(imageNames->data[i],  hdu->header, readout->image, config);
         writeImage(maskNames->data[i],   hdu->header, readout->mask, config);
-        writeImage(weightNames->data[i], hdu->header, readout->weight, config);
+        writeImage(varianceNames->data[i], hdu->header, readout->variance, config);
 
         pmCell *inCell = readout->parent; // Input cell
@@ -609 +609 @@
     // Start threading
     ppStackThreadInit();
-    ppStackThreadData *stack = ppStackThreadDataSetup(cells, imageNames, maskNames, weightNames, config);
+    ppStackThreadData *stack = ppStackThreadDataSetup(cells, imageNames, maskNames, varianceNames, config);
 
     psTimerStart("PPSTACK_INITIAL");
@@ -1023 +1023 @@
             psString imageResolved = pmConfigConvertFilename(imageNames->data[i], config, false, false);
             psString maskResolved = pmConfigConvertFilename(maskNames->data[i], config, false, false);
-            psString weightResolved = pmConfigConvertFilename(weightNames->data[i], config, false, false);
+            psString varianceResolved = pmConfigConvertFilename(varianceNames->data[i], config, false, false);
             if (unlink(imageResolved) == -1 || unlink(maskResolved) == -1 ||
-                unlink(weightResolved) == -1) {
+                unlink(varianceResolved) == -1) {
                 psWarning("Unable to delete temporary files for image %d", i);
             }
             psFree(imageResolved);
             psFree(maskResolved);
-            psFree(weightResolved);
+            psFree(varianceResolved);
         }
     }
     psFree(imageNames);
     psFree(maskNames);
-    psFree(weightNames);
+    psFree(varianceNames);
 
     psFree(inputMask);
@@ -1073 +1073 @@
         float renormWidth = psMetadataLookupS32(&mdok, recipe, "RENORM.WIDTH"); // Width of Gaussian phot
         psMaskType maskValue = pmConfigMaskGet("BLANK", config); // Bits to mask
-        if (!pmReadoutWeightRenormPhot(outRO, maskValue, renormNum, renormWidth,
-                                       renormMean, renormStdev, NULL)) {
+        if (!pmReadoutVarianceRenormPhot(outRO, maskValue, renormNum, renormWidth,
+                                         renormMean, renormStdev, NULL)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to renormalise variances.");
             psFree(outRO);

branches/pap_branch_20090128/ppStack/src/ppStackMatch.c

@@ -225 +225 @@
         }
 
-        // Read image, mask, weight
+        // Read image, mask, variance
         const char *tempImage = psMetadataLookupStr(NULL, recipe, "TEMP.IMAGE"); // Suffix for image
         const char *tempMask = psMetadataLookupStr(NULL, recipe, "TEMP.MASK"); // Suffix for mask
-        const char *tempWeight = psMetadataLookupStr(NULL, recipe, "TEMP.WEIGHT"); // Suffix for weight map
-        psString imageName = NULL, maskName = NULL, weightName = NULL; // Names for convolved images
+        const char *tempVariance = psMetadataLookupStr(NULL, recipe, "TEMP.VARIANCE"); // Suffix for variance map
+        psString imageName = NULL, maskName = NULL, varianceName = NULL; // Names for convolved images
         psStringAppend(&imageName, "%s.%d.%s", outName, numInput, tempImage);
         psStringAppend(&maskName, "%s.%d.%s", outName, numInput, tempMask);
-        psStringAppend(&weightName, "%s.%d.%s", outName, numInput, tempWeight);
+        psStringAppend(&varianceName, "%s.%d.%s", outName, numInput, tempVariance);
 
         if (!readImage(&readout->image, imageName, config) || !readImage(&readout->mask, maskName, config) ||
-            !readImage(&readout->weight, weightName, config)) {
+            !readImage(&readout->variance, varianceName, config)) {
             psError(PS_ERR_IO, false, "Unable to read previously produced image.");
             psFree(imageName);
             psFree(maskName);
-            psFree(weightName);
+            psFree(varianceName);
             return false;
         }
         psFree(imageName);
         psFree(maskName);
-        psFree(weightName);
+        psFree(varianceName);
     } else {
 #endif
@@ -383 +383 @@
                                                                                          "RENORM.STDEV"));
 
-                if (!pmReadoutWeightRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
+                if (!pmReadoutVarianceRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
                     psError(PS_ERR_UNKNOWN, false, "Unable to renormalise variances.");
                     psFree(output);
@@ -451 +451 @@
             psFree(readout->image);
             psFree(readout->mask);
-            psFree(readout->weight);
+            psFree(readout->variance);
             readout->image  = psMemIncrRefCounter(output->image);
             readout->mask   = psMemIncrRefCounter(output->mask);
-            readout->weight = psMemIncrRefCounter(output->weight);
+            readout->variance = psMemIncrRefCounter(output->variance);
         } else {
             // Fake the convolution
@@ -556 +556 @@
                                                                                  "RENORM.STDEV"));
 
-        if (!pmReadoutWeightRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
+        if (!pmReadoutVarianceRenormPixels(readout, maskBad, renormMean, renormStdev, rng)) {
             psError(PS_ERR_UNKNOWN, false, "Unable to renormalise variances.");
             psFree(output);

branches/pap_branch_20090128/ppStack/src/ppStackThread.c

@@ -38 +38 @@
         psFitsClose(stack->imageFits->data[i]);
         psFitsClose(stack->maskFits->data[i]);
-        psFitsClose(stack->weightFits->data[i]);
-        stack->imageFits->data[i] = stack->maskFits->data[i] = stack->weightFits->data[i] = NULL;
+        psFitsClose(stack->varianceFits->data[i]);
+        stack->imageFits->data[i] = stack->maskFits->data[i] = stack->varianceFits->data[i] = NULL;
     }
     psFree(stack->imageFits);
     psFree(stack->maskFits);
-    psFree(stack->weightFits);
+    psFree(stack->varianceFits);
     return;
 }
 
 ppStackThreadData *ppStackThreadDataSetup(const psArray *cells, const psArray *imageNames,
-                                          const psArray *maskNames, const psArray *weightNames,
+                                          const psArray *maskNames, const psArray *varianceNames,
                                           const pmConfig *config)
 {
@@ -54 +54 @@
     PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, imageNames, NULL);
     PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, maskNames, NULL);
-    PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, weightNames, NULL);
+    PS_ASSERT_ARRAYS_SIZE_EQUAL(cells, varianceNames, NULL);
 
     ppStackThreadData *stack = psAlloc(sizeof(ppStackThreadData)); // Thread data, to return
@@ -64 +64 @@
     stack->imageFits  = psArrayAlloc(numInputs);
     stack->maskFits   = psArrayAlloc(numInputs);
-    stack->weightFits = psArrayAlloc(numInputs);
+    stack->varianceFits = psArrayAlloc(numInputs);
     for (int i = 0; i < numInputs; i++) {
         if (!cells->data[i]) {
@@ -73 +73 @@
         psString imageResolved = pmConfigConvertFilename(imageNames->data[i], config, false, false);
         psString maskResolved = pmConfigConvertFilename(maskNames->data[i], config, false, false);
-        psString weightResolved = pmConfigConvertFilename(weightNames->data[i], config, false, false);
+        psString varianceResolved = pmConfigConvertFilename(varianceNames->data[i], config, false, false);
         stack->imageFits->data[i] = psFitsOpen(imageResolved, "r");
         stack->maskFits->data[i] = psFitsOpen(maskResolved, "r");
-        stack->weightFits->data[i] = psFitsOpen(weightResolved, "r");
+        stack->varianceFits->data[i] = psFitsOpen(varianceResolved, "r");
         psFree(imageResolved);
         psFree(maskResolved);
-        psFree(weightResolved);
-        if (!stack->imageFits->data[i] || !stack->maskFits->data[i] || !stack->weightFits->data[i]) {
+        psFree(varianceResolved);
+        if (!stack->imageFits->data[i] || !stack->maskFits->data[i] || !stack->varianceFits->data[i]) {
             psError(PS_ERR_UNKNOWN, false, "Unable to open convolved files %s, %s, %s",
-                    (char*)imageNames->data[i], (char*)maskNames->data[i], (char*)weightNames->data[i]);
+                    (char*)imageNames->data[i], (char*)maskNames->data[i], (char*)varianceNames->data[i]);
             return false;
         }
@@ -156 +156 @@
                 // override the recorded last scan
                 ro->thisImageScan  = thread->firstScan;
-                ro->thisWeightScan = thread->firstScan;
+                ro->thisVarianceScan = thread->firstScan;
                 ro->thisMaskScan   = thread->firstScan;
                 ro->lastImageScan  = thread->lastScan;
                 ro->lastMaskScan   = thread->lastScan;
-                ro->lastWeightScan = thread->lastScan;
+                ro->lastVarianceScan = thread->lastScan;
                 ro->forceScan      = true;
 
                 psFits *imageFits  = stack->imageFits->data[i]; // FITS file for image
                 psFits *maskFits   = stack->maskFits->data[i]; // FITS file for mask
-                psFits *weightFits = stack->weightFits->data[i]; // FITS file for weight
+                psFits *varianceFits = stack->varianceFits->data[i]; // FITS file for variance
 
 
@@ -189 +189 @@
                 }
 
-                if (pmReadoutMoreWeight(ro, weightFits, 0, rows, config)) {
+                if (pmReadoutMoreVariance(ro, varianceFits, 0, rows, config)) {
                     keepReading = true;
-                    if (!pmReadoutReadChunkWeight(ro, weightFits, 0, rows, overlap, config)) {
-                        psError(PS_ERR_IO, false, "Unable to read chunk %d for file PPSTACK.INPUT.WEIGHT %d",
+                    if (!pmReadoutReadChunkVariance(ro, varianceFits, 0, rows, overlap, config)) {
+                        psError(PS_ERR_IO, false,
+                                "Unable to read chunk %d for file PPSTACK.INPUT.VARIANCE %d",
                                 numChunk, i);
                         *status = false;