Changeset 27086

Timestamp:

Feb 25, 2010, 12:33:42 PM (16 years ago)

Author:

Paul Price

Message:

Fixing error codes for PSF-matching.

Location:

trunk/psModules/src/imcombine

Files:

• pmSubtraction.c (modified) (6 diffs)
• pmSubtractionAnalysis.c (modified) (6 diffs)
• pmSubtractionEquation.c (modified) (9 diffs)
• pmSubtractionIO.c (modified) (25 diffs)
• pmSubtractionMask.c (modified) (3 diffs)
• pmSubtractionMatch.c (modified) (44 diffs)
• pmSubtractionParams.c (modified) (5 diffs)
• pmSubtractionStamps.c (modified) (5 diffs)

trunk/psModules/src/imcombine/pmSubtraction.c

@@ -17 +17 @@
 #include <pslib.h>
 
+#include "pmErrorCodes.h"
 #include "pmHDU.h"                      // Required for pmFPA.h
 #include "pmFPA.h"
@@ -752 +753 @@
 
     if (stamp->status != PM_SUBTRACTION_STAMP_CALCULATE) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Stamp not marked for calculation.");
+        psError(PM_ERR_PROG, true, "Stamp not marked for calculation.");
         return false;
     }
@@ -808 +809 @@
 
     if (numStamps == 0) {
-        psError(PS_ERR_UNKNOWN, true, "No good stamps found.");
+        psError(PM_ERR_STAMPS, true, "No good stamps found.");
         psFree(mask);
         return -1;
@@ -816 +817 @@
                                   PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_QUARTILE); // Statistics for deviatns
     if (!psVectorStats(stats, deviations, NULL, mask, 0xff)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to measure statistics for deviations.");
+        psError(PM_ERR_DATA, false, "Unable to measure statistics for deviations.");
         psFree(stats);
         psFree(mask);
@@ -1199 +1200 @@
     if (region && psRegionIsNaN(*region)) {
         psString string = psRegionToString(*region);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Input region (%s) contains NAN values", string);
+        psError(PM_ERR_PROG, true, "Input region (%s) contains NAN values", string);
         psFree(string);
         return false;
@@ -1303 +1304 @@
 
     if (!psThreadPoolWait(false)) {
-        psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
+        psError(psErrorCodeLast(), false, "Error waiting for threads.");
         return false;
     }

trunk/psModules/src/imcombine/pmSubtractionAnalysis.c

@@ -74 +74 @@
                                                            false); // Image of the kernel
                 if (!kernel) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to generate kernel image.");
+                    psError(psErrorCodeLast(), false, "Unable to generate kernel image.");
                     psFree(convKernels);
                     return false;
@@ -81 +81 @@
                 if (psImageOverlaySection(convKernels, kernel, (i + KERNEL_MOSAIC) * fullSize,
                                           (j + KERNEL_MOSAIC) * fullSize, "=") == 0) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to overlay kernel image.");
+                    psError(psErrorCodeLast(), false, "Unable to overlay kernel image.");
                     psFree(kernel);
                     psFree(convKernels);
@@ -93 +93 @@
                                                       true); // Image of the kernel
                     if (!kernel) {
-                        psError(PS_ERR_UNKNOWN, false, "Unable to generate kernel image.");
+                        psError(psErrorCodeLast(), false, "Unable to generate kernel image.");
                         psFree(convKernels);
                         return false;
@@ -101 +101 @@
                                               (2 * KERNEL_MOSAIC + 1 + i + KERNEL_MOSAIC) * fullSize + 4,
                                               (j + KERNEL_MOSAIC) * fullSize, "=") == 0) {
-                        psError(PS_ERR_UNKNOWN, false, "Unable to overlay kernel image.");
+                        psError(psErrorCodeLast(), false, "Unable to overlay kernel image.");
                         psFree(kernel);
                         psFree(convKernels);
@@ -161 +161 @@
         psImage *image = pmSubtractionKernelImage(kernels, 0.5, 0.5, false); // Image of the kernel
         if (!image) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to generate image of kernel.");
+            psError(psErrorCodeLast(), false, "Unable to generate image of kernel.");
             return false;
         }
@@ -216 +216 @@
         psImage *image = pmSubtractionKernelImage(kernels, 0.5, 0.5, false); // Image of the kernel
         if (!image) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to generate image of kernel.");
+            psError(psErrorCodeLast(), false, "Unable to generate image of kernel.");
             return false;
         }

trunk/psModules/src/imcombine/pmSubtractionEquation.c

@@ -7 +7 @@
 #include <pslib.h>
 
+#include "pmErrorCodes.h"
 #include "pmSubtraction.h"
 #include "pmSubtractionKernels.h"
@@ -718 +719 @@
     // Generate convolutions: these are generated once and saved
     if (!pmSubtractionConvolveStamp(stamp, kernels, footprint)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to convolve stamp %d.", index);
+        psError(psErrorCodeLast(), false, "Unable to convolve stamp %d.", index);
         return NULL;
     }
@@ -869 +870 @@
 
     if (!psThreadPoolWait(true)) {
-        psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
+        psError(psErrorCodeLast(), false, "Error waiting for threads.");
         return false;
     }
@@ -989 +990 @@
             psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); // Statistics for norm
             if (!psVectorStats(stats, norms, NULL, NULL, 0)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to determine median normalisation");
+                psError(PM_ERR_DATA, false, "Unable to determine median normalisation");
                 psFree(stats);
                 psFree(sumMatrix);
@@ -1134 +1135 @@
             psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); // Statistics for norm
             if (!psVectorStats(stats, norms, NULL, NULL, 0)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to determine median normalisation");
+                psError(PM_ERR_DATA, false, "Unable to determine median normalisation");
                 psFree(stats);
                 psFree(sumMatrix);
@@ -1371 +1372 @@
                                                           false); // Kernel image
                 if (!image) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to generate image of kernel.");
+                    psError(psErrorCodeLast(), false, "Unable to generate image of kernel.");
                     return false;
                 }
@@ -1947 +1948 @@
             psVector *w = NULL;
             if (!psMatrixSVD (&U, &w, &V, kernelMatrix)) {
-                psError(PS_ERR_UNKNOWN, false, "failed to perform SVD on sumMatrix\n");
+                psError(psErrorCodeLast(), false, "failed to perform SVD on sumMatrix\n");
                 return NULL;
             }
@@ -2087 +2088 @@
             psImage *luMatrix = psMatrixLUDecomposition(NULL, &permutation, sumMatrix);
             if (!luMatrix) {
-                psError(PS_ERR_UNKNOWN, true, "LU Decomposition of least-squares matrix failed.\n");
+                psError(PM_ERR_DATA, true, "LU Decomposition of least-squares matrix failed.\n");
                 psFree(solution);
                 psFree(sumVector);
@@ -2100 +2101 @@
             psFree(permutation);
             if (!solution) {
-                psError(PS_ERR_UNKNOWN, true, "Failed to solve the least-squares system.\n");
+                psError(PM_ERR_DATA, true, "Failed to solve the least-squares system.\n");
                 psFree(solution);
                 psFree(sumVector);

trunk/psModules/src/imcombine/pmSubtractionIO.c

@@ -3 +3 @@
 #include <string.h>
 
+#include "pmErrorCodes.h"
 #include "pmHDU.h"
 #include "pmHDUUtils.h"
@@ -66 +67 @@
     }
     if (regions->n == 0) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "No subtraction regions found.");
+        psError(PM_ERR_PROG, true, "No subtraction regions found.");
         psFree(regions);
         return false;
@@ -87 +88 @@
 
     if (regions->n != kernels->n) {
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, "Number of regions (%ld) and kernels (%ld) don't match.\n",
+        psError(PM_ERR_PROG, true, "Number of regions (%ld) and kernels (%ld) don't match.\n",
                 regions->n, kernels->n);
         psFree(regions);
@@ -165 +166 @@
 
     if (!psFitsWriteTable(fits, header, rows, EXTNAME_KERNEL)) {
-        psError(PS_ERR_IO, false, "Unable to write subtraction kernel to FITS table.");
+        psError(psErrorCodeLast(), false, "Unable to write subtraction kernel to FITS table.");
         psFree(header);
         psFree(rows);
@@ -175 +176 @@
 
     if (image && !psFitsWriteImage(fits, header, image, 0, EXTNAME_IMAGE)) {
-        psError(PS_ERR_IO, false, "Unable to write subtraction kernel image.");
+        psError(psErrorCodeLast(), false, "Unable to write subtraction kernel image.");
         psFree(header);
         psFree(rows);
@@ -201 +202 @@
         thisView->readout = i;
         if (!pmReadoutWriteSubtractionKernels(readout, file->fits)) {
-            psError(PS_ERR_IO, false, "Failed to write %dth readout", i);
+            psError(psErrorCodeLast(), false, "Failed to write %dth readout", i);
             psFree(thisView);
             return false;
@@ -224 +225 @@
         thisView->cell = i;
         if (!pmCellWriteSubtractionKernels(cell, thisView, file, config)) {
-            psError(PS_ERR_IO, false, "Failed to write %dth cell", i);
+            psError(psErrorCodeLast(), false, "Failed to write %dth cell", i);
             psFree(thisView);
             return false;
@@ -247 +248 @@
         thisView->chip = i;
         if (!pmChipWriteSubtractionKernels(chip, thisView, file, config)) {
-            psError(PS_ERR_IO, false, "Failed to write %dth chip", i);
+            psError(psErrorCodeLast(), false, "Failed to write %dth chip", i);
             psFree(thisView);
             return false;
@@ -265 +266 @@
 
     if (!psFitsMoveExtName(fits, EXTNAME_KERNEL)) {
-        psError(PS_ERR_IO, false, "Unable to move to subtraction kernel table.");
+        psError(psErrorCodeLast(), false, "Unable to move to subtraction kernel table.");
         return false;
     }
@@ -271 +272 @@
     psArray *table = psFitsReadTable(fits); // Table of interest
     if (!table) {
-        psError(PS_ERR_IO, false, "Unable to read FITS table");
+        psError(psErrorCodeLast(), false, "Unable to read FITS table");
         return false;
     }
@@ -282 +283 @@
         TARGET = psMetadataLookup##SUFFIX(&mdok, row, NAME); \
         if (!mdok) { \
-            psError(PS_ERR_UNKNOWN, false, "Unable to find column %s in subtraction kernel table.", NAME); \
+            psError(PM_ERR_PROG, false, "Unable to find column %s in subtraction kernel table.", NAME); \
             psFree(table); \
             return false; \
@@ -325 +326 @@
             kernels->solution1 = psMemIncrRefCounter(psMetadataLookupPtr(&mdok, row, NAME_SOL1));
             if (!mdok) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to find column %s in subtraction kernel table.",
+                psError(PM_ERR_PROG, false, "Unable to find column %s in subtraction kernel table.",
                         NAME_SOL1);
                 psFree(kernels);
@@ -335 +336 @@
             kernels->solution1 = psMemIncrRefCounter(psMetadataLookupPtr(&mdok, row, NAME_SOL1));
             if (!mdok) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to find column %s in subtraction kernel table.",
+                psError(PM_ERR_PROG, false, "Unable to find column %s in subtraction kernel table.",
                         NAME_SOL1);
                 psFree(kernels);
@@ -343 +344 @@
             kernels->solution2 = psMemIncrRefCounter(psMetadataLookupPtr(&mdok, row, NAME_SOL2));
             if (!mdok) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to find column %s in subtraction kernel table.",
+                psError(PM_ERR_PROG, false, "Unable to find column %s in subtraction kernel table.",
                         NAME_SOL2);
                 psFree(kernels);
@@ -379 +380 @@
         pmReadout *readout = cell->readouts->data[i];
         thisView->readout = i;
-        pmReadoutReadSubtractionKernels(readout, file->fits);
+        if (!pmReadoutReadSubtractionKernels(readout, file->fits)) {
+            psError(psErrorCodeLast(), false, "Unable to read subtraction kernels from cell");
+            psFree(thisView);
+            return false;
+        }
         if (!readout->data_exists) {
             continue;
@@ -410 +415 @@
         pmCell *cell = chip->cells->data[i];
         thisView->cell = i;
-        pmCellReadSubtractionKernels(cell, thisView, file, config);
-        if (!cell->data_exists) {
+        if (!pmCellReadSubtractionKernels(cell, thisView, file, config)) {
+            psError(psErrorCodeLast(), false, "Unable to read subtraction kernels from cell");
+            psFree(thisView);
+            return false;
+        }
+         if (!cell->data_exists) {
             continue;
         }
@@ -419 +428 @@
 
     if (!pmConceptsReadChip(chip, PM_CONCEPT_SOURCE_HEADER, true, true, NULL)) {
-        psError(PS_ERR_IO, false, "Failed to read concepts for chip.\n");
+        psError(psErrorCodeLast(), false, "Failed to read concepts for chip.\n");
         return false;
     }
@@ -440 +449 @@
         pmChip *chip = fpa->chips->data[i];
         thisView->chip = i;
-        pmChipReadSubtractionKernels(chip, thisView, file, config);
+        if (!pmChipReadSubtractionKernels(chip, thisView, file, config)) {
+            psError(psErrorCodeLast(), false, "Unable to read subtraction kernels from chip");
+            psFree(thisView);
+            return false;
+        }
     }
     psFree(thisView);
 
     if (!pmConceptsReadFPA(fpa, PM_CONCEPT_SOURCE_HEADER, true, NULL)) {
-        psError(PS_ERR_IO, false, "Failed to read concepts for fpa.\n");
+        psError(psErrorCodeLast(), false, "Failed to read concepts for fpa.\n");
         return false;
     }
@@ -464 +477 @@
     if (view->chip == -1) {
         if (!pmFPAWriteSubtractionKernels(fpa, view, file, config)) {
-            psError(PS_ERR_IO, false, "Failed to write subtraction kernels from fpa");
+            psError(psErrorCodeLast(), false, "Failed to write subtraction kernels from fpa");
             psFree(fpa);
             return false;
@@ -473 +486 @@
 
     if (view->chip >= fpa->chips->n) {
-        psError(PS_ERR_UNKNOWN, false, "Writing chip == %d (>= chips->n == %ld)", view->chip, fpa->chips->n);
+        psError(PM_ERR_PROG, true, "Writing chip == %d (>= chips->n == %ld)", view->chip, fpa->chips->n);
         psFree(fpa);
         return false;
@@ -481 +494 @@
     if (view->cell == -1) {
         if (!pmChipWriteSubtractionKernels(chip, view, file, config)) {
-            psError(PS_ERR_IO, false, "Failed to write objects from chip");
+            psError(psErrorCodeLast(), false, "Failed to write objects from chip");
             psFree(fpa);
             return false;
@@ -490 +503 @@
 
     if (view->cell >= chip->cells->n) {
-        psError(PS_ERR_UNKNOWN, false, "Writing cell == %d (>= cells->n == %ld)",
+        psError(PM_ERR_PROG, true, "Writing cell == %d (>= cells->n == %ld)",
                 view->cell, chip->cells->n);
         psFree(fpa);
@@ -499 +512 @@
     if (view->readout == -1) {
         if (!pmCellWriteSubtractionKernels(cell, view, file, config)) {
-            psError(PS_ERR_IO, false, "Failed to write objects from cell");
+            psError(psErrorCodeLast(), false, "Failed to write objects from cell");
             psFree(fpa);
             return false;
@@ -508 +521 @@
 
     if (view->readout >= cell->readouts->n) {
-        psError(PS_ERR_UNKNOWN, false, "Writing readout == %d (>= readouts->n == %ld)",
+        psError(PM_ERR_PROG, true, "Writing readout == %d (>= readouts->n == %ld)",
                 view->readout, cell->readouts->n);
         psFree(fpa);
@@ -516 +529 @@
 
     if (!pmReadoutWriteSubtractionKernels(readout, file->fits)) {
-        psError(PS_ERR_IO, false, "Failed to write objects from readout %d", view->readout);
+        psError(psErrorCodeLast(), false, "Failed to write objects from readout %d", view->readout);
         psFree(fpa);
         return false;

trunk/psModules/src/imcombine/pmSubtractionMask.c

@@ -146 +146 @@
     if (!psImageConvolveMask(mask, mask, PM_SUBTRACTION_MASK_BAD_1, PM_SUBTRACTION_MASK_CONVOLVE_1,
                              -size, size, -size, size)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to convolve bad pixels from mask 1.");
+        psError(psErrorCodeLast(), false, "Unable to convolve bad pixels from mask 1.");
         psFree(mask);
         return NULL;
@@ -152 +152 @@
     if (!psImageConvolveMask(mask, mask, PM_SUBTRACTION_MASK_BAD_2, PM_SUBTRACTION_MASK_CONVOLVE_2,
                              -size, size, -size, size)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to convolve bad pixels from mask 2.");
+        psError(psErrorCodeLast(), false, "Unable to convolve bad pixels from mask 2.");
         psFree(mask);
         return NULL;
@@ -176 +176 @@
     if (!psImageConvolveMask(mask, mask, maskRej, PM_SUBTRACTION_MASK_REJ,
                              -footprint, footprint, -footprint, footprint)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to convolve bad pixels.");
+        psError(psErrorCodeLast(), false, "Unable to convolve bad pixels.");
         psFree(mask);
         return NULL;

trunk/psModules/src/imcombine/pmSubtractionMatch.c

@@ -104 +104 @@
     psTrace("psModules.imcombine", 3, "Extracting stamps...\n");
     if (!pmSubtractionStampsExtract(*stamps, ro1->image, ro2->image, variance, size, *region)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to extract stamps.");
+        psError(psErrorCodeLast(), false, "Unable to extract stamps.");
         return false;
     }
@@ -318 +318 @@
         while ((item = psMetadataGetAndIncrement(iter))) {
             if (item->type != PS_DATA_UNKNOWN) {
-                psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unexpected type for kernel.");
+                psError(PM_ERR_PROG, true, "Unexpected type for kernel.");
                 psFree(iter);
                 psFree(kernelList);
@@ -338 +338 @@
     }
     if (psListLength(kernelList) == 0) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Unable to find kernels");
+        psError(PM_ERR_PROG, true, "Unable to find kernels");
         psFree(kernelList);
         return false;
@@ -353 +353 @@
         while ((item = psMetadataGetAndIncrement(iter))) {
             if (item->type != PS_DATA_REGION) {
-                psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Unexpected type for region.");
+                psError(PM_ERR_PROG, true, "Unexpected type for region.");
                 psFree(iter);
                 psFree(kernels);
@@ -365 +365 @@
     }
     if (regions->n != kernels->n) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Differing number of kernels (%ld) and regions (%ld)",
+        psError(PM_ERR_PROG, true, "Differing number of kernels (%ld) and regions (%ld)",
                 kernels->n, regions->n);
         psFree(regions);
@@ -406 +406 @@
         if (!pmSubtractionAnalysis(outAnalysis, outHeader, kernel, region,
                                    ro1->image->numCols, ro1->image->numRows)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to generate QA data");
+            psError(psErrorCodeLast(), false, "Unable to generate QA data");
             psFree(outAnalysis);
             psFree(outHeader);
@@ -417 +417 @@
         if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, stride, maskBad, maskPoor, poorFrac,
                                    kernelError, covarFrac, region, kernel, true, useFFT)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to convolve image.");
+            psError(psErrorCodeLast(), false, "Unable to convolve image.");
             psFree(outAnalysis);
             psFree(outHeader);
@@ -555 +555 @@
             psStatsInit(bg);
             if (!psImageBackground(bg, NULL, ro1->image, ro1->mask, maskVal, rng)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to measure background statistics.");
+                psError(PM_ERR_DATA, false, "Unable to measure background statistics.");
                 psFree(bg);
                 goto MATCH_ERROR;
@@ -565 +565 @@
             psStatsInit(bg);
             if (!psImageBackground(bg, NULL, ro2->image, ro2->mask, maskVal, rng)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to measure background statistics.");
+                psError(PM_ERR_DATA, false, "Unable to measure background statistics.");
                 psFree(bg);
                 goto MATCH_ERROR;
@@ -640 +640 @@
                 psVector *buffer = NULL;// Buffer for stats
                 if (!psImageBackground(bgStats, &buffer, ro1->image, ro1->mask, maskVal, rng)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to measure background of image 1.");
+                    psError(PM_ERR_DATA, false, "Unable to measure background of image 1.");
                     psFree(bgStats);
                     psFree(buffer);
@@ -647 +647 @@
                 float bg1 = psStatsGetValue(bgStats, BG_STAT); // Background for image 1
                 if (!psImageBackground(bgStats, &buffer, ro2->image, ro2->mask, maskVal, rng)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to measure background of image 2.");
+                    psError(PM_ERR_DATA, false, "Unable to measure background of image 2.");
                     psFree(bgStats);
                     psFree(buffer);
@@ -667 +667 @@
                     break;
                   default:
-                    psError(PS_ERR_UNKNOWN, false, "Unable to determine subtraction order.");
+                    psError(psErrorCodeLast(), false, "Unable to determine subtraction order.");
                     goto MATCH_ERROR;
                 }
@@ -685 +685 @@
                 // generate the window function from the set of stamps
                 if (!pmSubtractionStampsGetWindow(stamps, size)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to get stamps window.");
+                    psError(psErrorCodeLast(), false, "Unable to get stamps window.");
                     goto MATCH_ERROR;
                 }
@@ -692 +692 @@
                 psTrace("psModules.imcombine", 3, "Calculating equation for normalization...\n");
                 if (!pmSubtractionCalculateEquation(stamps, kernels, SUBMODE)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -698 +698 @@
                 psTrace("psModules.imcombine", 3, "Solving equation for normalization...\n");
                 if (!pmSubtractionSolveEquation(kernels, stamps, SUBMODE)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -710 +710 @@
                 psTrace("psModules.imcombine", 3, "Calculating equation for kernels...\n");
                 if (!pmSubtractionCalculateEquation(stamps, kernels, PM_SUBTRACTION_EQUATION_KERNELS)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -717 +717 @@
                 psTrace("psModules.imcombine", 3, "Solving equation for kernels...\n");
                 if (!pmSubtractionSolveEquation(kernels, stamps, PM_SUBTRACTION_EQUATION_KERNELS)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -724 +724 @@
                 psVector *deviations = pmSubtractionCalculateDeviations(stamps, kernels); // Stamp deviations
                 if (!deviations) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate deviations.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate deviations.");
                     goto MATCH_ERROR;
                 }
@@ -733 +733 @@
                 numRejected = pmSubtractionRejectStamps(kernels, stamps, deviations, subMask, rej);
                 if (numRejected < 0) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to reject stamps.");
+                    psError(psErrorCodeLast(), false, "Unable to reject stamps.");
                     psFree(deviations);
                     goto MATCH_ERROR;
@@ -747 +747 @@
                 psTrace("psModules.imcombine", 3, "Calculating equation for normalization...\n");
                 if (!pmSubtractionCalculateEquation(stamps, kernels, SUBMODE)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -754 +754 @@
                 psTrace("psModules.imcombine", 3, "Solving equation for kernels...\n");
                 if (!pmSubtractionSolveEquation(kernels, stamps, SUBMODE)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -765 +765 @@
                 psTrace("psModules.imcombine", 3, "Calculating equation for normalization...\n");
                 if (!pmSubtractionCalculateEquation(stamps, kernels, PM_SUBTRACTION_EQUATION_KERNELS)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -772 +772 @@
                 psTrace("psModules.imcombine", 3, "Solving equation for kernels...\n");
                 if (!pmSubtractionSolveEquation(kernels, stamps, PM_SUBTRACTION_EQUATION_KERNELS)) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
                     goto MATCH_ERROR;
                 }
@@ -779 +779 @@
                 psVector *deviations = pmSubtractionCalculateDeviations(stamps, kernels); // Stamp deviations
                 if (!deviations) {
-                    psError(PS_ERR_UNKNOWN, false, "Unable to calculate deviations.");
+                    psError(psErrorCodeLast(), false, "Unable to calculate deviations.");
                     goto MATCH_ERROR;
                 }
@@ -791 +791 @@
 
             if (!pmSubtractionAnalysis(analysis, header, kernels, region, numCols, numRows)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to generate QA data");
+                psError(psErrorCodeLast(), false, "Unable to generate QA data");
                 goto MATCH_ERROR;
             }
@@ -800 +800 @@
             if (!pmSubtractionConvolve(conv1, conv2, ro1, ro2, subMask, stride, maskBad, maskPoor, poorFrac,
                                        kernelError, covarFrac, region, kernels, true, useFFT)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to convolve image.");
+                psError(psErrorCodeLast(), false, "Unable to convolve image.");
                 goto MATCH_ERROR;
             }
@@ -820 +820 @@
 
     if (conv1 && !pmSubtractionBorder(conv1->image, conv1->variance, conv1->mask, size, maskBad)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to set border of convolved image.");
+        psError(psErrorCodeLast(), false, "Unable to set border of convolved image.");
         goto MATCH_ERROR;
     }
     if (conv2 && !pmSubtractionBorder(conv2->image, conv2->variance, conv2->mask, size, maskBad)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to set border of convolved image.");
+        psError(psErrorCodeLast(), false, "Unable to set border of convolved image.");
         goto MATCH_ERROR;
     }
@@ -1023 +1023 @@
         } else {
             if (!pmSubtractionOrderStamp(ratios, mask, stamps, models, modelSums, i, bg1, bg2)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to measure PSF width for stamp %d", i);
+                psError(psErrorCodeLast(), false, "Unable to measure PSF width for stamp %d", i);
                 psFree(models);
                 psFree(modelSums);
@@ -1034 +1034 @@
 
     if (!psThreadPoolWait(true)) {
-        psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
+        psError(psErrorCodeLast(), false, "Error waiting for threads.");
         psFree(models);
         psFree(modelSums);
@@ -1047 +1047 @@
     psStats *stats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN);
     if (!psVectorStats(stats, ratios, NULL, mask, 0xff)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to calculate statistics for moments ratio.");
+        psError(psErrorCodeLast(), false, "Unable to calculate statistics for moments ratio.");
         psFree(mask);
         psFree(ratios);
@@ -1083 +1083 @@
     psTrace("psModules.imcombine", 3, "Calculating %s normalization equation...\n", description);
     if (!pmSubtractionCalculateEquation(stamps, kernels, SUBMODE)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+        psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
         return false;
     }
@@ -1089 +1089 @@
     psTrace("psModules.imcombine", 3, "Solving %s normalization equation...\n", description);
     if (!pmSubtractionSolveEquation(kernels, stamps, SUBMODE)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+        psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
         return false;
     }
@@ -1099 +1099 @@
     psTrace("psModules.imcombine", 3, "Calculating %s kernel coeffs equation...\n", description);
     if (!pmSubtractionCalculateEquation(stamps, kernels, PM_SUBTRACTION_EQUATION_KERNELS)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+        psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
         return false;
     }
@@ -1105 +1105 @@
     psTrace("psModules.imcombine", 3, "Solving %s kernel coeffs equation...\n", description);
     if (!pmSubtractionSolveEquation(kernels, stamps, PM_SUBTRACTION_EQUATION_KERNELS)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+        psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
         return false;
     }
@@ -1113 +1113 @@
     psVector *deviations = pmSubtractionCalculateDeviations(stamps, kernels); // Stamp deviations
     if (!deviations) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to calculate deviations.");
+        psError(psErrorCodeLast(), false, "Unable to calculate deviations.");
         return false;
     }
@@ -1120 +1120 @@
     long numRejected = pmSubtractionRejectStamps(kernels, stamps, deviations, subMask, rej);
     if (numRejected < 0) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to reject stamps.");
+        psError(psErrorCodeLast(), false, "Unable to reject stamps.");
         psFree(deviations);
         return false;
@@ -1130 +1130 @@
         psTrace("psModules.imcombine", 3, "Calculating %s normalization equation...\n", description);
         if (!pmSubtractionCalculateEquation(stamps, kernels, PM_SUBTRACTION_EQUATION_ALL)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+            psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
             return false;
         }
@@ -1136 +1136 @@
         psTrace("psModules.imcombine", 3, "Resolving %s equation...\n", description);
         if (!pmSubtractionSolveEquation(kernels, stamps, PM_SUBTRACTION_EQUATION_ALL)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+            psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
             return false;
         }
@@ -1147 +1147 @@
         psTrace("psModules.imcombine", 3, "Calculating %s normalization equation...\n", description);
         if (!pmSubtractionCalculateEquation(stamps, kernels, PM_SUBTRACTION_EQUATION_KERNELS)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+            psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
             return false;
         }
@@ -1153 +1153 @@
         psTrace("psModules.imcombine", 3, "Resolving %s equation...\n", description);
         if (!pmSubtractionSolveEquation(kernels, stamps, PM_SUBTRACTION_EQUATION_KERNELS)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to calculate least-squares equation.");
+            psError(psErrorCodeLast(), false, "Unable to calculate least-squares equation.");
             return false;
         }
@@ -1161 +1161 @@
         psVector *deviations = pmSubtractionCalculateDeviations(stamps, kernels); // Stamp deviations
         if (!deviations) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to calculate deviations.");
+            psError(psErrorCodeLast(), false, "Unable to calculate deviations.");
             return false;
         }
@@ -1167 +1167 @@
         long numRejected = pmSubtractionRejectStamps(kernels, stamps, deviations, subMask, NAN);
         if (numRejected < 0) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to reject stamps.");
+            psError(psErrorCodeLast(), false, "Unable to reject stamps.");
             psFree(deviations);
             return false;
@@ -1191 +1191 @@
 
     if (!subtractionModeTest(stamps1, kernels1, "convolve 1", subMask1, rej)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to test subtraction with convolution of image 1");
+        psError(psErrorCodeLast(), false, "Unable to test subtraction with convolution of image 1");
         psFree(stamps1);
         psFree(kernels1);
@@ -1206 +1206 @@
 
     if (!subtractionModeTest(stamps2, kernels2, "convolve 2", subMask2, rej)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to test subtraction with convolution of image 2");
+        psError(psErrorCodeLast(), false, "Unable to test subtraction with convolution of image 2");
         psFree(stamps2);
         psFree(kernels2);

trunk/psModules/src/imcombine/pmSubtractionParams.c

@@ -8 +8 @@
 #include <pslib.h>
 
+#include "pmErrorCodes.h"
 #include "pmSubtractionStamps.h"
 #include "pmSubtraction.h"
@@ -281 +282 @@
         }
         if (!pmSubtractionConvolveStamp(stamp, kernels, footprint)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to convolve stamp %d.", i);
+            psError(psErrorCodeLast(), false, "Unable to convolve stamp %d.", i);
             psFree(targets);
             psFree(kernels);
@@ -297 +298 @@
         }
         if (!isfinite(sum1)) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
+            psError(PM_ERR_DATA, true,
                     "Sum of 1/sigma^2 is non-finite for stamp %d (%d,%d)\n",
                     i, (int)stamp->x, (int)stamp->y);
@@ -369 +370 @@
 
         if (bestIndex == -1) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to find best kernel component in round %d.", iter);
+            psError(PM_ERR_DATA, true, "Unable to find best kernel component in round %d.", iter);
             psFree(targets);
             psFree(sumC);
@@ -408 +409 @@
 
     if (cutIndex < 0) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Unable to converge to tolerance %g\n", tolerance);
+        psError(PM_ERR_DATA, true, "Unable to converge to tolerance %g\n", tolerance);
         psFree(ranking);
         psFree(kernels);

trunk/psModules/src/imcombine/pmSubtractionStamps.c

@@ -369 +369 @@
         if (psRegionIsNaN(*region)) {
             psString string = psRegionToString(*region);
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Input region (%s) contains NAN values", string);
+            psError(PM_ERR_PROG, true, "Input region (%s) contains NAN values", string);
             psFree(string);
             return false;
@@ -376 +376 @@
             region->y0 < 0 || region->y1 > numRows) {
             psString string = psRegionToString(*region);
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Input region (%s) does not fit in image (%dx%d)",
+            psError(PM_ERR_PROG, true, "Input region (%s) does not fit in image (%dx%d)",
                     string, numCols, numRows);
             psFree(string);
@@ -785 +785 @@
 
         if (x < bounds.x0 + size || x > bounds.x1 - size || y < bounds.y0 + size || y > bounds.y1 - size) {
-            psError(PS_ERR_UNKNOWN, false, "Stamp %d (%d,%d) is within the region border.\n", i, x, y);
+            psError(PM_ERR_PROG, false, "Stamp %d (%d,%d) is within the region border.\n", i, x, y);
             return false;
         }
@@ -881 +881 @@
 
     if (!stamps) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to set stamps from sources.");
+        psError(psErrorCodeLast(), false, "Unable to set stamps from sources.");
     }
 
@@ -898 +898 @@
     psArray *data = psVectorsReadFromFile(filename, "%f %f");
     if (!data) {
-        psError(PS_ERR_IO, false, "Unable to read stamps file %s", filename);
+        psError(psErrorCodeLast(), false, "Unable to read stamps file %s", filename);
         return NULL;
     }