Changeset 23352 for branches/cnb_branches/cnb_branch_20090301/ppSub

Timestamp:

Mar 17, 2009, 12:08:50 PM (17 years ago)

Author:

beaumont

Message:

merged with head

Location:

branches/cnb_branches/cnb_branch_20090301

Files:

• . (modified) (1 prop)
• ppSub (modified) (1 prop)
• ppSub/src/Makefile.am (modified) (1 diff)
• ppSub/src/ppSub.c (modified) (2 diffs)
• ppSub/src/ppSub.h (modified) (1 diff)
• ppSub/src/ppSubArguments.c (modified) (10 diffs)
• ppSub/src/ppSubBackground.c (modified) (1 diff)
• ppSub/src/ppSubCamera.c (modified) (2 diffs)
• ppSub/src/ppSubLoop.c (modified) (4 diffs)
• ppSub/src/ppSubMakePSF.c (modified) (1 diff)
• ppSub/src/ppSubMatchPSFs.c (modified) (3 diffs)
• ppSub/src/ppSubReadoutUpdate.c (modified) (1 diff)
• ppSub/src/ppSubVarianceFactors.c (modified) (1 diff)
• ppSub/src/ppSubVersion.c (modified) (1 diff)
• ppSub/test/fake.c (modified) (1 diff)

branches/cnb_branches/cnb_branch_20090301/ppSub/src/Makefile.am

@@ -1 +1 @@
 bin_PROGRAMS = ppSub ppSubKernel
 
-ppSub_CPPFLAGS = $(PSLIB_CFLAGS) $(PSMODULE_CFLAGS) $(PPSTATS_CFLAGS) $(PSPHOT_CFLAGS) $(PPSUB_CFLAGS)
+# PPSUB_VERSION=`if [ -e ../../VERSION ]; then cat ../../VERSION; else svnversion; fi`
+# PPSUB_BRANCH=`if [ -e ../../BRANCH ]; then cat ../../BRANCH; else svn info | sed -n -e '/URL:/ h' -e '/Repository Root:/ { x; H; x; s|Repository Root: \(.*\)\nURL: \1\(.*\)|\2| ; s|^/|| ; s|/[a-zA-Z]*/src.*|| ; p }'; fi`
+# PPSUB_SOURCE=`if [ -e ../../SOURCE ]; then cat ../../SOURCE; else svn info | sed -n -e 's/Repository UUID: // p'; fi`
+# 
+# # Force recompilation of ppSubVersion.c, since it gets the version information
+# ppSubVersion.c: FORCE
+#       touch ppSubVersion.c
+# FORCE: ;
+
+ppSub_CPPFLAGS = $(PSLIB_CFLAGS) $(PSMODULE_CFLAGS) $(PPSTATS_CFLAGS) $(PSPHOT_CFLAGS) $(PPSUB_CFLAGS) -DPPSUB_VERSION=$(SVN_VERSION) -DPPSUB_BRANCH=$(SVN_BRANCH) -DPPSUB_SOURCE=$(SVN_SOURCE)
 ppSub_LDFLAGS  = $(PSLIB_LIBS)   $(PSMODULE_LIBS)   $(PPSTATS_LIBS)   $(PSPHOT_LIBS)   $(PPSUB_LIBS)
 

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSub.c

@@ -34 +34 @@
         goto die;
     }
+
+    ppSubVersionPrint();
 
     if (!pmModelClassInit()) {
@@ -75 +77 @@
     psTimerStop();
 
-    pmSubtractionVisualClose(); //close plot windows, if -visual is set
+    pmVisualClose(); //close plot windows, if -visual is set
     psFree(config);
     pmModelClassCleanup();

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSub.h

@@ -89 +89 @@
     );
 
-/// Put the program version information into a metadata
-void ppSubVersionMetadata(psMetadata *metadata ///< Metadata to populate
+/// Put the program version information into a header
+bool ppSubVersionHeader(psMetadata *header ///< Header to populate
     );
+
+/// Print version information
+void ppSubVersionPrint(void);
 
 

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubArguments.c

@@ -29 +29 @@
 {
     fprintf(stderr, "\nPan-STARRS PSF-matched image subtraction\n\n");
-    fprintf(stderr, "Usage: %s INPUT.fits REFERENCE.fits OUTPUT_ROOT \n"
-            "\t[-psf REFERENCE.psf.fits] [-sources REFERENCE.cmf]\n\n"
+    fprintf(stderr, "Usage: %s OUTPUT_ROOT \n"
+            "\t[-psf REFERENCE.psf.fits]\n\n"
             "This subtracts the convolved REFERENCE from the INPUT, by default.\n",
             program);
@@ -191 +191 @@
 bool ppSubArgumentsSetup(int argc, char *argv[], pmConfig *config)
 {
-    int argnum;                         // Argument Number
+    //    int argnum;                         // Argument Number
     assert(config);
 
@@ -200 +200 @@
     }
 
-    if ((argnum = psArgumentGet(argc, argv, "-psphot-visual"))) {
-        psArgumentRemove(argnum, &argc, argv);
-        psphotSetVisual(true);
-    }
-
-    pmConfigFileSetsMD(config->arguments, &argc, argv, "PPSUB.SOURCES", "-sources", NULL);
 
     psMetadata *arguments = config->arguments; // Command-line arguments
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-inimage", 0, "Input image", NULL);
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-inmask", 0, "Input mask image", NULL);
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-invariance", 0, "Input variance image", NULL);
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-insources", 0, "Input source list", NULL);
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-refimage", 0, "Reference image", NULL);
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-refmask", 0, "Reference mask image", NULL);
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-refvariance", 0, "Reference variance image", NULL);
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-refsources", 0, "Reference source list", NULL);
+    psMetadataAddStr(arguments, PS_LIST_TAIL, "-kernel", 0, "Precalculated kernel to apply", NULL);
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-stats", 0, "Statistics file", NULL);
     psMetadataAddF32(arguments, PS_LIST_TAIL, "-region", 0, "Size of iso-kernel region", NAN);
@@ -228 +227 @@
     psMetadataAddF32(arguments, PS_LIST_TAIL, "-spacing", 0, "Typical stamp spacing (pixels)", NAN);
     psMetadataAddS32(arguments, PS_LIST_TAIL, "-footprint", 0, "Stamp footprint half-size (pixels)", -1);
+    psMetadataAddF32(arguments, PS_LIST_TAIL, "-source-radius", 0, "Source matching radius (pixels)", NAN);
     psMetadataAddS32(arguments, PS_LIST_TAIL, "-stride", 0, "Size of convolution patches (pixels)", -1);
     psMetadataAddF32(arguments, PS_LIST_TAIL, "-threshold", 0, "Minimum threshold for stamps (ADU)", NAN);
@@ -256 +256 @@
     psMetadataAddBool(arguments, PS_LIST_TAIL, "-visual", 0, "Show diagnostic plots", NULL);
 
-    if (argc == 1 || !psArgumentParse(arguments, &argc, argv) || argc != 4) {
+    if (argc == 1 || !psArgumentParse(arguments, &argc, argv) || argc != 2) {
         usage(argv[0], arguments, config);
     }
 
-    fileList("INPUT", argv[1], "Name of the input image",     config);
-    fileList("REF",   argv[2], "Name of the reference image", config);
     psMetadataAddStr(config->arguments, PS_LIST_TAIL, "OUTPUT", 0, "Name of the output image", argv[3]);
 
+
+    const char *inImage = psMetadataLookupStr(NULL, arguments, "-inimage"); // Name of input image
+    if (inImage && strlen(inImage) > 0) {
+        fileList("INPUT", inImage, "Name of the input image", config);
+    }
     const char *inMask = psMetadataLookupStr(NULL, arguments, "-inmask"); // Name of input mask
     if (inMask && strlen(inMask) > 0) {
@@ -272 +275 @@
         fileList("INPUT.VARIANCE", inVariance, "Name of the input variance image", config);
     }
-
+    const char *inSources = psMetadataLookupStr(NULL, arguments, "-insources"); // Name of input source list
+    if (inSources && strlen(inSources) > 0) {
+        fileList("INPUT.SOURCES", inSources, "Name of the input source list", config);
+    }
+
+    const char *refImage = psMetadataLookupStr(NULL, arguments, "-refimage"); // Name of reference image
+    if (refImage && strlen(refImage) > 0) {
+        fileList("INPUT", refImage, "Name of the reference image", config);
+    }
     const char *refMask = psMetadataLookupStr(NULL, arguments, "-refmask"); // Name of reference mask
     if (refMask && strlen(refMask) > 0) {
@@ -280 +291 @@
     if (refVariance && strlen(refVariance) > 0) {
         fileList("REF.VARIANCE", refVariance, "Name of the reference variance image", config);
+    }
+    const char *refSources = psMetadataLookupStr(NULL, arguments, "-refsources"); // Name of ref source list
+    if (refSources && strlen(refSources) > 0) {
+        fileList("REF.SOURCES", refSources, "Name of the reference source list", config);
+    }
+
+    const char *kernel = psMetadataLookupStr(NULL, arguments, "-kernel"); // Name of kernel
+    if (kernel && strlen(kernel) > 0) {
+        fileList("KERNEL", kernel, "Name of the kernel to apply", config);
     }
 
@@ -304 +324 @@
     }
 
-    VALUE_ARG_RECIPE_FLOAT("-region",     "REGION.SIZE",     F32);
-    VALUE_ARG_RECIPE_INT("-size",         "KERNEL.SIZE",     S32, 0);
-    VALUE_ARG_RECIPE_INT("-order",        "SPATIAL.ORDER",   S32, -1);
-    VALUE_ARG_RECIPE_FLOAT("-spacing",    "STAMP.SPACING",   F32);
-    VALUE_ARG_RECIPE_INT("-rings-order",  "RINGS.ORDER",     S32, -1);
-    VALUE_ARG_RECIPE_INT("-inner",        "INNER",           S32, -1);
-    VALUE_ARG_RECIPE_INT("-spam-binning", "SPAM.BINNING",    S32, 0);
-    VALUE_ARG_RECIPE_INT("-footprint",    "STAMP.FOOTPRINT", S32, -1);
-    VALUE_ARG_RECIPE_INT("-stride",       "STRIDE",          S32, -1);
-    VALUE_ARG_RECIPE_FLOAT("-threshold",  "STAMP.THRESHOLD", F32);
-    VALUE_ARG_RECIPE_INT("-iter",         "ITER",            S32, -1);
-    VALUE_ARG_RECIPE_FLOAT("-rej",        "REJ",             F32);
-    VALUE_ARG_RECIPE_FLOAT("-sys",        "SYS",             F32);
-    VALUE_ARG_RECIPE_FLOAT("-badfrac",    "BADFRAC",         F32);
-    VALUE_ARG_RECIPE_FLOAT("-penalty",    "PENALTY",         F32);
-    VALUE_ARG_RECIPE_FLOAT("-poor-frac",  "POOR.FRACTION",   F32);
-    VALUE_ARG_RECIPE_INT("-bin1",         "BIN1",            S32, 0);
-    VALUE_ARG_RECIPE_INT("-bin2",         "BIN2",            S32, 0);
+    VALUE_ARG_RECIPE_FLOAT("-region",        "REGION.SIZE",     F32);
+    VALUE_ARG_RECIPE_INT("-size",            "KERNEL.SIZE",     S32, 0);
+    VALUE_ARG_RECIPE_INT("-order",           "SPATIAL.ORDER",   S32, -1);
+    VALUE_ARG_RECIPE_FLOAT("-spacing",       "STAMP.SPACING",   F32);
+    VALUE_ARG_RECIPE_INT("-rings-order",     "RINGS.ORDER",     S32, -1);
+    VALUE_ARG_RECIPE_INT("-inner",           "INNER",           S32, -1);
+    VALUE_ARG_RECIPE_INT("-spam-binning",    "SPAM.BINNING",    S32, 0);
+    VALUE_ARG_RECIPE_INT("-footprint",       "STAMP.FOOTPRINT", S32, -1);
+    VALUE_ARG_RECIPE_FLOAT("-source-radius", "SOURCE.RADIUS",   F32);
+    VALUE_ARG_RECIPE_INT("-stride",          "STRIDE",          S32, -1);
+    VALUE_ARG_RECIPE_FLOAT("-threshold",     "STAMP.THRESHOLD", F32);
+    VALUE_ARG_RECIPE_INT("-iter",            "ITER",            S32, -1);
+    VALUE_ARG_RECIPE_FLOAT("-rej",           "REJ",             F32);
+    VALUE_ARG_RECIPE_FLOAT("-sys",           "SYS",             F32);
+    VALUE_ARG_RECIPE_FLOAT("-badfrac",       "BADFRAC",         F32);
+    VALUE_ARG_RECIPE_FLOAT("-penalty",       "PENALTY",         F32);
+    VALUE_ARG_RECIPE_FLOAT("-poor-frac",     "POOR.FRACTION",   F32);
+    VALUE_ARG_RECIPE_INT("-bin1",            "BIN1",            S32, 0);
+    VALUE_ARG_RECIPE_INT("-bin2",            "BIN2",            S32, 0);
 
     valueArgRecipeStr(arguments, recipe, "-mask-in",   "MASK.IN",  recipe);
@@ -360 +381 @@
 
     if (psMetadataLookupBool(NULL, arguments, "-visual")) {
-        pmSubtractionSetVisual(true);
+        pmVisualSetVisual(true);
     }
 
@@ -376 +397 @@
     psTrace("ppSub", 1, "Done reading command-line arguments\n");
 
-    // Dump configuration, now that's it's settled
-    psBool status;
-    psString dump_file =  psMetadataLookupStr(&status, config->arguments, "-dumpconfig");
-    if (dump_file) {
-        pmConfigCamerasCull(config, NULL);
-        pmConfigRecipesCull(config, "PPSUB,PPSTATS,PSPHOT,MASKS");
-
-        pmFPAfile *input = psMetadataLookupPtr(NULL, config->files, "PPSUB.INPUT"); // Input file
-        pmConfigDump(config, input->fpa, dump_file);
-    }
-
     // XXX move this to ppSubArguments
     int threads = psMetadataLookupS32(NULL, config->arguments, "-threads"); // Number of threads

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubBackground.c

@@ -53 +53 @@
         }
     }
-    psImageBinning *binning = psMetadataLookupPtr(&mdok, psphotRecipe,
+    psImageBinning *binning = psMetadataLookupPtr(&mdok, modelRO->analysis,
                                                   "PSPHOT.BACKGROUND.BINNING"); // Binning for model
     psImage *modelImage = modelRO->image; // Background model

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubCamera.c

@@ -22 +22 @@
 #include "ppSub.h"
 
+// Define an input file
+static pmFPAfile *defineInputFile(pmConfig *config,// Configuration
+                                  pmFPAfile *bind,    // File to which to bind, or NULL
+                                  char *filerule,     // Name of file rule
+                                  char *argname,      // Argument name
+                                  pmFPAfileType fileType // Type of file
+    )
+{
+    bool status;
+
+    // look for the file on the RUN metadata
+    pmFPAfile *file = pmFPAfileDefineFromRun(&status, config, filerule); // File to return
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "Failed to load file definition for %s", filerule);
+        return NULL;
+    }
+    if (!file) {
+        // look for the file on the argument list
+        if (bind) {
+            file = pmFPAfileBindFromArgs(&status, bind, config, filerule, argname);
+        } else {
+            file = pmFPAfileDefineFromArgs(&status, config, filerule, argname);
+        }
+        if (!status) {
+            psError(PS_ERR_UNKNOWN, false, "Failed to load file definition for %s", filerule);
+            return false;
+        }
+    }
+
+    if (!file) {
+        return NULL;
+    }
+
+    if (file->type != fileType) {
+        psError(PS_ERR_UNKNOWN, true, "%s is not of type %s", filerule, pmFPAfileStringFromType(fileType));
+        return NULL;
+    }
+
+    return file;
+}
+
+// Define an output file
+static pmFPAfile *defineOutputFile(pmConfig *config, // Configuration
+                                   pmFPAfile *template,    // File to use as basis for definition
+                                   char *filerule,     // Name of file rule
+                                   pmFPAfileType fileType // Type of file
+    )
+{
+
+    pmFPAfile *file = pmFPAfileDefineFromFile(config, template, 1, 1, filerule);
+    if (!file) {
+        psError(PS_ERR_IO, false, _("Unable to generate output file from %s"), filerule);
+        return NULL;
+    }
+    if (file->type != fileType) {
+        psError(PS_ERR_IO, true, "%s is not of type %s", filerule, pmFPAfileStringFromType(fileType));
+        return NULL;
+    }
+
+    return file;
+}
+
+
+// Define an output file that will be used in a calculation
+// This means it might already be available in the RUN metadata
+static pmFPAfile *defineCalcFile(pmConfig *config, // Configuration
+                                 pmFPAfile *bind,    // File to which to bind, or NULL
+                                 char *filerule,     // Name of file rule
+                                 pmFPAfileType fileType // Type of file
+    )
+{
+    bool status;
+
+    // look for the file on the RUN metadata
+    pmFPAfile *file = pmFPAfileDefineFromRun(&status, config, filerule); // File to return
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "Failed to load file definition for %s", filerule);
+        return NULL;
+    }
+    if (file) {
+        // It's an input
+        file->save = false;
+    }
+
+    // define new version of file
+    if (!file) {
+        pmFPAfileDefineOutput(config, bind ? bind->fpa : NULL, filerule);
+        if (!status) {
+            psError(PS_ERR_UNKNOWN, false, "Failed to load file definition for %s", filerule);
+            return false;
+        }
+        if (file) {
+            // It's an output
+            file->save = true;
+        }
+    }
+
+    if (!file) {
+        return NULL;
+    }
+
+    if (file->type != fileType) {
+        psError(PS_ERR_UNKNOWN, true, "%s is not of type %s", filerule, pmFPAfileStringFromType(fileType));
+        return NULL;
+    }
+
+    return file;
+}
+
+
 bool ppSubCamera(pmConfig *config)
 {
-    bool status = false;                // result from pmFPAfileDefine operations
+    psAssert(config, "Require configuration");
 
     // Input image
-    pmFPAfile *input = pmFPAfileDefineFromArgs(&status, config, "PPSUB.INPUT", "INPUT");
-    if (!status || !input) {
+    pmFPAfile *input = defineInputFile(config, NULL, "PPSUB.INPUT", "INPUT", PM_FPA_FILE_IMAGE);
+    if (!input) {
         psError(PS_ERR_IO, false, "Failed to build FPA from PPSUB.INPUT");
         return false;
     }
-    if (input->type != PM_FPA_FILE_IMAGE) {
-        psError(PS_ERR_IO, true, "PPSUB.INPUT is not of type IMAGE");
-        return false;
-    }
-
-    // Input mask
-    pmFPAfile *inputMask = pmFPAfileBindFromArgs(&status, input, config, "PPSUB.INPUT.MASK", "INPUT.MASK");
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "Failed to load file definition PPSUB.INPUT.MASK");
-        return NULL;
-    }
-    if (inputMask && inputMask->type != PM_FPA_FILE_MASK) {
-        psError(PS_ERR_IO, true, "PPSUB.INPUT.MASK is not of type MASK");
-        return false;
-    }
-
-    // Input variance map
-    pmFPAfile *inputVariance = pmFPAfileBindFromArgs(&status, input, config, "PPSUB.INPUT.VARIANCE", "INPUT.VARIANCE");
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "Failed to load file definition PPSUB.INPUT.VARIANCE");
-        return NULL;
-    }
-    if (inputVariance && inputVariance->type != PM_FPA_FILE_VARIANCE) {
-        psError(PS_ERR_IO, true, "PPSUB.INPUT.VARIANCE is not of type VARIANCE");
-        return false;
-    }
+    defineInputFile(config, input, "PPSUB.INPUT.MASK", "INPUT.MASK", PM_FPA_FILE_MASK);
+    pmFPAfile *inVar = defineInputFile(config, input, "PPSUB.INPUT.VARIANCE", "INPUT.VARIANCE",
+                                       PM_FPA_FILE_VARIANCE);
+    defineInputFile(config, input, "PPSUB.INPUT.SOURCES", "INPUT.SOURCES", PM_FPA_FILE_CMF);
 
     // Reference image
-    status = false;
-    pmFPAfile *ref = pmFPAfileDefineFromArgs(&status, config, "PPSUB.REF", "REF");
+    pmFPAfile *ref = defineInputFile(config, NULL, "PPSUB.REF", "REF", PM_FPA_FILE_IMAGE);
     if (!ref) {
         psError(PS_ERR_IO, false, "Failed to build FPA from PPSUB.REF");
         return false;
     }
-    if (ref->type != PM_FPA_FILE_IMAGE) {
-        psError(PS_ERR_IO, true, "PPSUB.REF is not of type IMAGE");
-        return false;
-    }
-
-    // Reference mask
-    pmFPAfile *refMask = pmFPAfileBindFromArgs(&status, ref, config, "PPSUB.REF.MASK", "REF.MASK");
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "Failed to load file definition PPSUB.REF.MASK");
-        return NULL;
-    }
-    if (refMask && refMask->type != PM_FPA_FILE_MASK) {
-        psError(PS_ERR_IO, true, "PPSUB.REF.MASK is not of type MASK");
-        return false;
-    }
-
-    // Reference variance map
-    pmFPAfile *refVariance = pmFPAfileBindFromArgs(&status, ref, config, "PPSUB.REF.VARIANCE", "REF.VARIANCE");
-    if (!status) {
-        psError (PS_ERR_UNKNOWN, false, "Failed to load file definition PPSUB.REF.VARIANCE");
-        return NULL;
-    }
-    if (refVariance && refVariance->type != PM_FPA_FILE_VARIANCE) {
-        psError(PS_ERR_IO, true, "PPSUB.REF.VARIANCE is not of type VARIANCE");
-        return false;
-    }
+    defineInputFile(config, ref, "PPSUB.REF.MASK", "REF.MASK", PM_FPA_FILE_MASK);
+    pmFPAfile *refVar = defineInputFile(config, ref, "PPSUB.REF.VARIANCE", "REF.VARIANCE",
+                                        PM_FPA_FILE_VARIANCE);
+    defineInputFile(config, ref, "PPSUB.REF.SOURCES", "REF.SOURCES", PM_FPA_FILE_CMF);
+
 
     // Output image
-    pmFPAfile *output = pmFPAfileDefineFromFile(config, input, 1, 1, "PPSUB.OUTPUT");
-    if (!output) {
-        psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.OUTPUT"));
-        return false;
-    }
-    if (output->type != PM_FPA_FILE_IMAGE) {
-        psError(PS_ERR_IO, true, "PPSUB.OUTPUT is not of type IMAGE");
+    pmFPAfile *output = defineOutputFile(config, input, "PPSUB.OUTPUT", PM_FPA_FILE_IMAGE);
+    pmFPAfile *outMask = defineOutputFile(config, output, "PPSUB.OUTPUT.MASK", PM_FPA_FILE_MASK);
+    if (!output || !outMask) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to define output files");
         return false;
     }
     output->save = true;
-
-    // Output mask
-    pmFPAfile *outMask = pmFPAfileDefineOutput(config, output->fpa, "PPSUB.OUTPUT.MASK");
-    if (!outMask) {
-        psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.OUTPUT.MASK"));
-        return false;
-    }
-    if (outMask->type != PM_FPA_FILE_MASK) {
-        psError(PS_ERR_IO, true, "PPSUB.OUTPUT.MASK is not of type MASK");
-        return false;
-    }
     outMask->save = true;
-
-    // Output variance
-    if (inputVariance && refVariance) {
-        pmFPAfile *outVariance = pmFPAfileDefineOutput(config, output->fpa, "PPSUB.OUTPUT.VARIANCE");
-        if (!outVariance) {
-            psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.OUTPUT.VARIANCE"));
-            return false;
-        }
-        if (outVariance->type != PM_FPA_FILE_VARIANCE) {
-            psError(PS_ERR_IO, true, "PPSUB.OUTPUT.VARIANCE is not of type VARIANCE");
-            return false;
-        }
-        outVariance->save = true;
-    }
+    pmFPAfile *outVar = NULL;
+    if (inVar && refVar) {
+        outVar = defineOutputFile(config, output, "PPSUB.OUTPUT.VARIANCE", PM_FPA_FILE_VARIANCE);
+        if (!outVar) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to define output files");
+            return false;
+        }
+        outVar->save = true;
+    }
+
 
     // Convolved input image
-    pmFPAfile *inConv = pmFPAfileDefineFromFile(config, input, 1, 1, "PPSUB.INPUT.CONV");
-    if (!inConv) {
-        psError(PS_ERR_IO, false, _("Unable to generate output file for PPSUB.INPUT.CONV"));
-        return false;
-    }
-    if (output->type != PM_FPA_FILE_IMAGE) {
-        psError(PS_ERR_IO, true, "PPSUB.INPUT.CONV is not of type IMAGE");
-        return false;
-    }
-    // XXX should be based on recipe : inConv->save = true;
-
-    // Convolved input mask
-    pmFPAfile *inConvMask = pmFPAfileDefineOutput(config, inConv->fpa, "PPSUB.INPUT.CONV.MASK");
-    if (!inConvMask) {
-        psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.INPUT.CONV.MASK"));
-        return false;
-    }
-    if (inConvMask->type != PM_FPA_FILE_MASK) {
-        psError(PS_ERR_IO, true, "PPSUB.INPUT.CONV.MASK is not of type MASK");
-        return false;
-    }
-    // XXX should be based on recipe : inConvMask->save = true;
-
-    // Convolved input variance
-    if (inputVariance) {
-        pmFPAfile *inConvVariance = pmFPAfileDefineOutput(config, inConv->fpa, "PPSUB.INPUT.CONV.VARIANCE");
-        if (!inConvVariance) {
-            psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.OUTPUT.VARIANCE"));
-            return false;
-        }
-        if (inConvVariance->type != PM_FPA_FILE_VARIANCE) {
-            psError(PS_ERR_IO, true, "PPSUB.INPUT.CONV.VARIANCE is not of type VARIANCE");
-            return false;
-        }
-        // XXX should be based on recipe : inConvVariance->save = true;
+    pmFPAfile *inConvImage = defineOutputFile(config, input, "PPSUB.INPUT.CONV", PM_FPA_FILE_IMAGE);
+    pmFPAfile *inConvMask = defineOutputFile(config, input, "PPSUB.INPUT.CONV.MASK", PM_FPA_FILE_MASK);
+    if (!inConvImage || !inConvMask) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to define output files");
+        return false;
+    }
+    if (inVar) {
+        pmFPAfile *inConvVar = defineOutputFile(config, input, "PPSUB.INPUT.CONV.VARIANCE",
+                                                PM_FPA_FILE_VARIANCE);
+        if (!inConvVar) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to define output files");
+            return false;
+        }
     }
 
     // Convolved ref image
-    pmFPAfile *refConv = pmFPAfileDefineFromFile(config, ref, 1, 1, "PPSUB.REF.CONV");
-    if (!refConv) {
-        psError(PS_ERR_IO, false, _("Unable to generate output file for PPSUB.REF.CONV"));
-        return false;
-    }
-    if (output->type != PM_FPA_FILE_IMAGE) {
-        psError(PS_ERR_IO, true, "PPSUB.REF.CONV is not of type IMAGE");
-        return false;
-    }
-    // XXX should be based on recipe : refConv->save = true;
-
-    // Convolved ref mask
-    pmFPAfile *refConvMask = pmFPAfileDefineOutput(config, refConv->fpa, "PPSUB.REF.CONV.MASK");
-    if (!refConvMask) {
-        psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.REF.CONV.MASK"));
-        return false;
-    }
-    if (refConvMask->type != PM_FPA_FILE_MASK) {
-        psError(PS_ERR_IO, true, "PPSUB.REF.CONV.MASK is not of type MASK");
-        return false;
-    }
-    // XXX should be based on recipe : refConvMask->save = true;
-
-    // Convolved ref variance
-    if (refVariance) {
-        pmFPAfile *refConvVariance = pmFPAfileDefineOutput(config, refConv->fpa, "PPSUB.REF.CONV.VARIANCE");
-        if (!refConvVariance) {
-            psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.OUTPUT.VARIANCE"));
-            return false;
-        }
-        if (refConvVariance->type != PM_FPA_FILE_VARIANCE) {
-            psError(PS_ERR_IO, true, "PPSUB.REF.CONV.VARIANCE is not of type VARIANCE");
-            return false;
-        }
-        // XXX should be based on recipe : refConvVariance->save = true;
-    }
+    pmFPAfile *refConvImage = defineOutputFile(config, input, "PPSUB.REF.CONV", PM_FPA_FILE_IMAGE);
+    pmFPAfile *refConvMask = defineOutputFile(config, input, "PPSUB.REF.CONV.MASK", PM_FPA_FILE_MASK);
+    if (!refConvImage || !refConvMask) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to define output files");
+        return false;
+    }
+    if (refVar) {
+        pmFPAfile *refConvVar = defineOutputFile(config, input, "PPSUB.REF.CONV.VARIANCE",
+                                                 PM_FPA_FILE_VARIANCE);
+        if (!refConvVar) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to define output files");
+            return false;
+        }
+    }
+
 
     // Output JPEGs
@@ -230 +235 @@
 
     // Output subtraction kernel
-    pmFPAfile *outKernels = pmFPAfileDefineOutput(config, output->fpa, "PPSUB.OUTPUT.KERNELS");
-    if (!outKernels) {
-        psError(PS_ERR_IO, false, _("Unable to generate output file from PPSUB.OUTPUT.KERNELS"));
-        return false;
-    }
-    if (outKernels->type != PM_FPA_FILE_SUBKERNEL) {
-        psError(PS_ERR_IO, true, "PPSUB.OUTPUT.KERNELS is not of type SUBKERNEL");
-        return false;
-    }
-    outKernels->save = true;
-
-#if 0
-    if (!pmFPAAddSourceFromFormat(output->fpa, "Subtraction", output->format)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to generate output FPA.");
-        return false;
-    }
-#endif
-
-    pmFPAfile *sources = pmFPAfileDefineFromArgs(&status, config, "PPSUB.SOURCES", "PPSUB.SOURCES");
-    if (!status) {
-        psError(PS_ERR_IO, false, "Failed to load file definition PPSUB.SOURCES");
-        return false;
-    }
-    if (sources && sources->type != PM_FPA_FILE_CMF) {
-        psError(PS_ERR_IO, true, "PPSUB.SOURCES is not of type CMF");
+    pmFPAfile *kernel = defineCalcFile(config, output, "PPSUB.OUTPUT.KERNELS", PM_FPA_FILE_SUBKERNEL);
+    if (!kernel) {
+        psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to define file PPSUB.OUTPUT.KERNELS");
         return false;
     }

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubLoop.c

@@ -23 +23 @@
 bool ppSubLoop(pmConfig *config)
 {
+    psAssert(config, "Require configuration.");
+
+    pmConfigCamerasCull(config, NULL);
+    pmConfigRecipesCull(config, "PPSUB,PPSTATS,PSPHOT,MASKS,JPEG");
+
     bool mdok;                          // Status of MD lookup
     const char *statsName = psMetadataLookupStr(&mdok, config->arguments, "STATS"); // Filename for statistics
@@ -59 +64 @@
 
     pmFPAview *view = pmFPAviewAlloc(0); // Pointer into FPA hierarchy
-    pmHDU *lastHDU = NULL;              // Last HDU that was updated
 
     // Iterate over the FPA hierarchy
@@ -99 +103 @@
             if (!pmFPAfileIOChecks(config, view, PM_FPA_BEFORE)) {
                 return false;
-            }
-
-            // Put version information into the header
-            pmHDU *hdu = pmHDUFromCell(inCell);
-            if (hdu && hdu != lastHDU) {
-                if (!hdu->header) {
-                    hdu->header = psMetadataAlloc();
-                }
-                ppSubVersionMetadata(hdu->header);
-                lastHDU = hdu;
             }
 
@@ -183 +177 @@
     }
 
+    psString dump_file = psMetadataLookupStr(&mdok, config->arguments, "-dumpconfig");
+    if (dump_file) {
+
+        pmFPAfile *input = psMetadataLookupPtr(NULL, config->files, "PPSUB.INPUT"); // Input file
+        pmConfigDump(config, input->fpa, dump_file);
+    }
+
     return true;
 }

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubMakePSF.c

@@ -81 +81 @@
     // Extract the loaded sources from the associated readout, and generate PSF
     // Here, we assume the image is background-subtracted
-    pmReadout *sourcesRO = pmFPAfileThisReadout(config->files, view, "PPSUB.SOURCES");
-    psArray *sources = psMetadataLookupPtr(&mdok, sourcesRO->analysis, "PSPHOT.SOURCES");
+    psArray *sources = psMetadataLookupPtr(&mdok, minuend->analysis, "PSPHOT.SOURCES");
     if (!psphotReadoutFindPSF(config, view, sources)) {
         psError(PS_ERR_UNKNOWN, false, "Unable to perform photometry on subtracted image.");

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubMatchPSFs.c

@@ -49 +49 @@
     bool mdok;                          // Status of MD lookup
 
+    // Load pre-calculated kernel, if available
+    pmReadout *kernelRO = pmFPAfileThisReadout(config->files, view, "PPSUB.OUTPUT.KERNEL"); // RO with kernel
+
     // Sources in image, used for stamps: these must be loaded from previous analysis stages
-    pmReadout *sourcesRO = pmFPAfileThisReadout(config->files, view, "PPSUB.SOURCES"); // Readout with sources
-    psArray *sources = NULL;            // Sources in image; used for stamps
-    if (sourcesRO) {
-        sources = psMetadataLookupPtr(&mdok, sourcesRO->analysis, "PSPHOT.SOURCES");
+    psArray *inSources = psMetadataLookupPtr(&mdok, inRO->analysis, "PSPHOT.SOURCES"); // Input source list
+    psArray *refSources = psMetadataLookupPtr(&mdok, refRO->analysis, "PSPHOT.SOURCES"); // Ref source list
+
+    psArray *sources = NULL;            // Merged list of sources
+    if (inSources && refSources) {
+        float radius = psMetadataLookupF32(NULL, recipe, "SOURCE.RADIUS"); // Matching radius
+        psArray *lists = psArrayAlloc(2); // Source lists
+        lists->data[0] = psMemIncrRefCounter(inSources);
+        lists->data[1] = psMemIncrRefCounter(refSources);
+        sources = pmSourceMatchMerge(lists, radius);
+        psFree(lists);
+        if (!sources) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to merge source lists");
+            return false;
+        }
+    } else if (inSources) {
+        sources = psMemIncrRefCounter(inSources);
+    } else if (refSources) {
+        sources = psMemIncrRefCounter(refSources);
     }
+
+    psMetadataAddArray(inConv->analysis, PS_LIST_TAIL, "PSPHOT.SOURCES", PS_META_REPLACE,
+                       "Merged source list", sources);
+    psMetadataAddArray(refConv->analysis, PS_LIST_TAIL, "PSPHOT.SOURCES", PS_META_REPLACE,
+                       "Merged source list", sources);
+    psFree(sources);                    // Drop reference
 
     int footprint = psMetadataLookupS32(NULL, recipe, "STAMP.FOOTPRINT"); // Stamp half-size
@@ -113 +137 @@
 
     // Match the PSFs
-    if (!pmSubtractionMatch(inConv, refConv, inRO, refRO, footprint, stride, regionSize, spacing, threshold,
-                            sources, stampsName, type, size, order, widths, orders, inner, ringsOrder,
-                            binning, penalty, optimum, optWidths, optOrder, optThresh, iter, rej, sys,
-                            maskVal, maskBad, maskPoor, poorFrac, badFrac, subMode)) {
-        psError(PS_ERR_UNKNOWN, false, "Unable to match images.");
-        return false;
+    if (kernelRO) {
+        if (!pmSubtractionMatchPrecalc(inConv, refConv, inRO, refRO, kernelRO->analysis,
+                                       stride, sys, maskVal, maskBad, maskPoor, poorFrac, badFrac)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to convolve images.");
+            return false;
+        }
+    } else {
+        if (!pmSubtractionMatch(inConv, refConv, inRO, refRO, footprint, stride, regionSize, spacing,
+                                threshold, sources, stampsName, type, size, order, widths, orders, inner,
+                                ringsOrder, binning, penalty, optimum, optWidths, optOrder, optThresh, iter,
+                                rej, sys, maskVal, maskBad, maskPoor, poorFrac, badFrac, subMode)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to match images.");
+            return false;
+        }
     }
 
@@ -129 +161 @@
 
     // XXX drop the pixels associated with inRO and refRO (now that we have inConv and refConf)
-
+#ifdef TESTING
     psphotSaveImage (NULL, inRO->image, "inRO.fits");
     psphotSaveImage (NULL, refRO->image, "refRO.fits");
     psphotSaveImage (NULL, inConv->image, "inConv.fits");
     psphotSaveImage (NULL, refConv->image, "refConv.fits");
+#endif
 
     return true;

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubReadoutUpdate.c

@@ -44 +44 @@
     psMetadataAddStr(outHDU->header, PS_LIST_TAIL, "PPSUB.INPUT", 0,
                      "Subtraction input", inFile->filename);
+    ppSubVersionHeader(outHDU->header);
 
     // Statistics on the matching

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubVarianceFactors.c

@@ -65 +65 @@
 
     psStats *vfStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN); // Statistics
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
 
     // mask these values when examining the background

branches/cnb_branches/cnb_branch_20090301/ppSub/src/ppSubVersion.c

@@ -19 +19 @@
 #include <psmodules.h>
 #include <ppStats.h>
+#include <psphot.h>
 
 #include "ppSub.h"
 
-static const char *cvsTag = "$Name: not supported by cvs2svn $";///< CVS tag name
+#ifndef PPSUB_VERSION
+#error "PPSUB_VERSION is not set"
+#endif
+#ifndef PPSUB_BRANCH
+#error "PPSUB_BRANCH is not set"
+#endif
+#ifndef PPSUB_SOURCE
+#error "PPSUB_SOURCE is not set"
+#endif
+
+#define xstr(s) str(s)
+#define str(s) #s
 
 psString ppSubVersion(void)
 {
-    psString version = NULL;            // Version, to return
-    psStringAppend(&version, "%s-%s",PACKAGE_NAME,PACKAGE_VERSION);
-    return version;
+    char *value = NULL;
+    psStringAppend(&value, "%s@%s", xstr(PPSUB_BRANCH), xstr(PPSUB_VERSION));
+    return value;
+}
+
+psString ppSubSource(void)
+{
+    return psStringCopy(xstr(PPSUB_SOURCE));
 }
 
 psString ppSubVersionLong(void)
 {
-    psString version = ppSubVersion(); // Version, to return
-    psString tag = psStringStripCVS(cvsTag, "Name"); // CVS tag
-    psStringAppend(&version, " (cvs tag %s) %s, %s", tag, __DATE__, __TIME__);
-    psFree(tag);
+    psString version = ppSubVersion();  // Version, to return
+    psString source = ppSubSource();    // Source
+
+    psStringPrepend(&version, "ppSub ");
+    psStringAppend(&version, " from %s, built %s, %s", source, __DATE__, __TIME__);
+    psFree(source);
+
+#ifdef __OPTIMIZE__
+    psStringAppend(&version, " optimised");
+#else
+    psStringAppend(&version, " unoptimised");
+#endif
+
     return version;
-}
+};
 
 
-void ppSubVersionMetadata(psMetadata *metadata)
+bool ppSubVersionHeader(psMetadata *header)
 {
-    PS_ASSERT_METADATA_NON_NULL(metadata,);
-
-    psString pslib = psLibVersionLong();// psLib version
-    psString psmodules = psModulesVersionLong(); // psModules version
-    psString ppStats = ppStatsVersionLong(); // ppStats version
-    psString ppSub = ppSubVersionLong(); // ppSub version
+    PS_ASSERT_METADATA_NON_NULL(header, false);
 
     psTime *time = psTimeGetNow(PS_TIME_TAI); // The time now
     psString timeString = psTimeToISO(time); // The time in an ISO string
     psFree(time);
-    psString head = NULL;               // Head string
-    psStringAppend(&head, "ppSub processing at %s. Component information:", timeString);
+    psString history = NULL;               // History string
+    psStringAppend(&history, "ppSub at %s", timeString);
+    psFree(timeString);
+    psMetadataAddStr(header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, NULL, history);
+    psFree(history);
+
+    psLibVersionHeader(header);
+    psModulesVersionHeader(header);
+    psphotVersionHeader(header);
+    ppStatsVersionHeader(header);
+
+    psString version = ppSubVersion(); // Software version
+    psString source  = ppSubSource();  // Software source
+
+    psStringPrepend(&version, "ppSub version: ");
+    psStringPrepend(&source, "ppSub source: ");
+
+    psMetadataAddStr(header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, NULL, version);
+    psMetadataAddStr(header, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, NULL, source);
+
+    psFree(version);
+    psFree(source);
+
+    return true;
+}
+
+void ppSubVersionPrint(void)
+{
+    psTime *time = psTimeGetNow(PS_TIME_TAI); // The time now
+    psString timeString = psTimeToISO(time); // The time in an ISO string
+    psFree(time);
+    psLogMsg("ppSub", PS_LOG_INFO, "ppSub at %s", timeString);
     psFree(timeString);
 
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, head, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, pslib, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, psmodules, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, ppStats, "");
-    psMetadataAddStr(metadata, PS_LIST_TAIL, "HISTORY", PS_META_DUPLICATE_OK, ppSub, "");
+    psString pslib = psLibVersionLong();// psLib version
+    psString psmodules = psModulesVersionLong(); // psModules version
+    psString psphot = psphotVersionLong(); // psphot version
+    psString ppStats = ppStatsVersionLong(); // ppStats version
+    psString ppSub = ppSubVersionLong(); // ppSub version
 
-    psFree(head);
+    psLogMsg("ppSub", PS_LOG_INFO, "%s", pslib);
+    psLogMsg("ppSub", PS_LOG_INFO, "%s", psmodules);
+    psLogMsg("ppSub", PS_LOG_INFO, "%s", psphot);
+    psLogMsg("ppSub", PS_LOG_INFO, "%s", ppStats);
+    psLogMsg("ppSub", PS_LOG_INFO, "%s", ppSub);
+
     psFree(pslib);
     psFree(psmodules);
+    psFree(psphot);
     psFree(ppStats);
     psFree(ppSub);

branches/cnb_branches/cnb_branch_20090301/ppSub/test/fake.c

@@ -89 +89 @@
 int main(int argc, char *argv[])
 {
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0); // Random number generator
+    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS); // Random number generator
 
     // Images to generate